Add comprehensive installation and setup documentation

- Add GETTING_STARTED.md with quick start guide and development modes
- Add INSTALL.sh automated installation script
- Add INSTALLATION_CHECKLIST.md, INSTALLATION_SUCCESS.md, and INSTALLATION_SUMMARY.md
- Add QUICK_REFERENCE.md for common commands
- Add SETUP_GUIDE.md with detailed setup instructions
- Update README.md with improved project overview
- Add did-wallet app dependencies and node_modules

apps/web5-dwn/node_modules/run-parallel-limit/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) Feross Aboukhadijeh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

apps/web5-dwn/node_modules/run-parallel-limit/README.md

@@ -0,0 +1,94 @@
+# run-parallel-limit [![travis][travis-image]][travis-url] [![npm][npm-image]][npm-url] [![downloads][downloads-image]][downloads-url] [![javascript style guide][standard-image]][standard-url]
+
+[travis-image]: https://img.shields.io/travis/feross/run-parallel-limit/master.svg
+[travis-url]: https://travis-ci.org/feross/run-parallel-limit
+[npm-image]: https://img.shields.io/npm/v/run-parallel-limit.svg
+[npm-url]: https://npmjs.org/package/run-parallel-limit
+[downloads-image]: https://img.shields.io/npm/dm/run-parallel-limit.svg
+[downloads-url]: https://npmjs.org/package/run-parallel-limit
+[standard-image]: https://img.shields.io/badge/code_style-standard-brightgreen.svg
+[standard-url]: https://standardjs.com
+
+### Run an array of functions in parallel, but limit the number of tasks executing at the same time
+
+![run-parallel-limit](img.png) [![Sauce Test Status](https://saucelabs.com/browser-matrix/run-parallel-limit.svg)](https://saucelabs.com/u/run-parallel-limit)
+
+### install
+
+```
+npm install run-parallel-limit
+```
+
+### usage
+
+#### parallelLimit(tasks, limit, [callback])
+
+Run the `tasks` array of functions in parallel, with a maximum of `limit` tasks executing
+at the same time. If any of the functions pass an error to its callback, the main
+`callback` is immediately called with the value of the error. Once the `tasks` have
+completed, the results are passed to the final `callback` as an array.
+
+Note that the `tasks` are not executed in batches, so there is no guarantee that the first
+`limit` tasks will complete before any others are started.
+
+It is also possible to use an object instead of an array. Each property will be run as a
+function and the results will be passed to the final `callback` as an object instead of
+an array. This can be a more readable way of handling the results.
+
+##### arguments
+
+- `tasks` - An array or object containing functions to run. Each function is passed a
+`callback(err, result)` which it must call on completion with an error `err` (which can
+be `null`) and an optional `result` value.
+- `limit` - The maximum number of `tasks` to run at any time.
+- `callback(err, results)` - An optional callback to run once all the functions have
+completed. This function gets a results array (or object) containing all the result
+arguments passed to the task callbacks.
+
+##### example
+
+```js
+var parallelLimit = require('run-parallel-limit')
+
+var tasks = [
+  function (callback) {
+    setTimeout(function () {
+      callback(null, 'one')
+    }, 200)
+  },
+  function (callback) {
+    setTimeout(function () {
+      callback(null, 'two')
+    }, 100)
+  },
+  ... hundreds more tasks ...
+]
+
+parallelLimit(tasks, 5, function (err, results) {
+  // optional callback
+  // the results array will equal ['one', 'two', ...] even though
+  // the second function had a shorter timeout.
+})
+```
+
+The above code runs with a concurrency `limit` of 5, so at most 5 tasks will be running at
+any given time.
+
+This module is basically equavalent to
+[`async.parallelLimit`](https://github.com/caolan/async#parallellimittasks-limit-callback),
+but it's handy to just have the one function you need instead of the kitchen sink.
+Modularity! Especially handy if you're serving to the browser and need to reduce your
+javascript bundle size.
+
+Works great in the browser with [browserify](http://browserify.org/)!
+
+### see also
+
+- [run-auto](https://github.com/feross/run-auto)
+- [run-parallel](https://github.com/feross/run-parallel)
+- [run-series](https://github.com/feross/run-series)
+- [run-waterfall](https://github.com/feross/run-waterfall)
+
+### license
+
+MIT. Copyright (c) [Feross Aboukhadijeh](http://feross.org).

apps/web5-dwn/node_modules/run-parallel-limit/index.js

@@ -0,0 +1,70 @@
+/*! run-parallel-limit. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
+module.exports = runParallelLimit
+
+const queueMicrotask = require('queue-microtask')
+
+function runParallelLimit (tasks, limit, cb) {
+  if (typeof limit !== 'number') throw new Error('second argument must be a Number')
+  let results, len, pending, keys, isErrored
+  let isSync = true
+  let next
+
+  if (Array.isArray(tasks)) {
+    results = []
+    pending = len = tasks.length
+  } else {
+    keys = Object.keys(tasks)
+    results = {}
+    pending = len = keys.length
+  }
+
+  function done (err) {
+    function end () {
+      if (cb) cb(err, results)
+      cb = null
+    }
+    if (isSync) queueMicrotask(end)
+    else end()
+  }
+
+  function each (i, err, result) {
+    results[i] = result
+    if (err) isErrored = true
+    if (--pending === 0 || err) {
+      done(err)
+    } else if (!isErrored && next < len) {
+      let key
+      if (keys) {
+        key = keys[next]
+        next += 1
+        tasks[key](function (err, result) { each(key, err, result) })
+      } else {
+        key = next
+        next += 1
+        tasks[key](function (err, result) { each(key, err, result) })
+      }
+    }
+  }
+
+  next = limit
+  if (!pending) {
+    // empty
+    done(null)
+  } else if (keys) {
+    // object
+    keys.some(function (key, i) {
+      tasks[key](function (err, result) { each(key, err, result) })
+      if (i === limit - 1) return true // early return
+      return false
+    })
+  } else {
+    // array
+    tasks.some(function (task, i) {
+      task(function (err, result) { each(i, err, result) })
+      if (i === limit - 1) return true // early return
+      return false
+    })
+  }
+
+  isSync = false
+}

apps/web5-dwn/node_modules/run-parallel-limit/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "run-parallel-limit",
+  "description": "Run an array of functions in parallel, but limit the number of tasks executing at the same time",
+  "version": "1.1.0",
+  "author": {
+    "name": "Feross Aboukhadijeh",
+    "email": "feross@feross.org",
+    "url": "https://feross.org"
+  },
+  "bugs": {
+    "url": "https://github.com/feross/run-parallel-limit/issues"
+  },
+  "dependencies": {
+    "queue-microtask": "^1.2.2"
+  },
+  "devDependencies": {
+    "airtap": "^3.0.0",
+    "standard": "*",
+    "tape": "^5.1.1"
+  },
+  "homepage": "https://github.com/feross/run-parallel-limit",
+  "keywords": [
+    "parallel",
+    "async",
+    "function",
+    "callback",
+    "asynchronous",
+    "run",
+    "array",
+    "run parallel",
+    "limit",
+    "max",
+    "queue",
+    "run parallel limit",
+    "max tasks",
+    "tasks"
+  ],
+  "license": "MIT",
+  "main": "index.js",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/feross/run-parallel-limit.git"
+  },
+  "scripts": {
+    "test": "standard && npm run test-node && npm run test-browser",
+    "test-browser": "airtap -- test/*.js",
+    "test-browser-local": "airtap --local -- test/*.js",
+    "test-node": "tape test/*.js"
+  },
+  "funding": [
+    {
+      "type": "github",
+      "url": "https://github.com/sponsors/feross"
+    },
+    {
+      "type": "patreon",
+      "url": "https://www.patreon.com/feross"
+    },
+    {
+      "type": "consulting",
+      "url": "https://feross.org/support"
+    }
+  ]
+}