New Player Controller Base

src/Instancing/main.js

+const Koa           = require('koa');
+const Router        = require("@koa/router");
+const bodyParser    = require('koa-body');
+const fetch         = require('node-fetch');
+
+async function main(){
+
+    const ue4Router = require('./ue4/router.js');
+
+    const app = new Koa();
+    const router = new Router();
+
+    router.use('/ue4', ue4Router.routes(), ue4Router.allowedMethods());
+
+    app.use(bodyParser());
+
+    app.use(router.routes()).use(router.allowedMethods());
+
+    const response = await fetch('http://localhost:1337/instances/add-world-server');
+    // const data = await response.json();
+    // console.log(data);
+
+    app.listen(8181, () => console.log('Server Started'));
+
+    
+}
+
+main();
\ No newline at end of file

src/Instancing/node_modules/@koa/router/LICENSE

+The MIT License (MIT)
+
+Copyright (c) 2015 Alexander C. Mingoia
+
+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.

src/Instancing/node_modules/@koa/router/README.md

+# @koa/router
+
+Router middleware for [koa](https://github.com/koajs/koa)
+
+[![NPM version](https://img.shields.io/npm/v/@koa/router.svg?style=flat)](https://npmjs.org/package/@koa/router) 
+[![NPM Downloads](https://img.shields.io/npm/dm/@koa/router.svg?style=flat)](https://npmjs.org/package/@koa/router) 
+[![Node.js Version](https://img.shields.io/node/v/@koa/router.svg?style=flat)](http://nodejs.org/download/)
+[![Build Status](https://img.shields.io/travis/koajs/router.svg?style=flat)](http://travis-ci.org/koajs/router)
+[![gitter](https://img.shields.io/gitter/room/koajs/koa.svg?style=flat)](https://gitter.im/koajs/koa)
+
+* Express-style routing (`app.get`, `app.put`, `app.post`, etc.)
+* Named URL parameters
+* Named routes with URL generation
+* Responds to `OPTIONS` requests with allowed methods
+* Support for `405 Method Not Allowed` and `501 Not Implemented`
+* Multiple route middleware
+* Multiple and nestable routers
+* `async/await` support
+
+## Migrating to 7 / Koa 2
+
+- The API has changed to match the new promise-based middleware
+  signature of koa 2. See the
+  [koa 2.x readme](https://github.com/koajs/koa/tree/2.0.0-alpha.3) for more
+  information.
+- Middleware is now always run in the order declared by `.use()` (or `.get()`,
+  etc.), which matches Express 4 API.
+
+## Installation
+
+Install using [npm](https://www.npmjs.org/):
+
+```sh
+npm install @koa/router
+```
+
+## [API Reference](./API.md)
+
+## Contributing
+
+Please submit all issues and pull requests to the [koajs/router](http://github.com/koajs/router) repository!
+
+## Tests
+
+Run tests using `npm test`.
+
+## Support
+
+If you have any problem or suggestion please open an issue [here](https://github.com/koajs/router/issues).
+
+## Call for Maintainers
+
+This module is forked from the original [koa-router](https://github.com/ZijianHe/koa-router) due to its lack of activity. `koa-router` is the most widely used router module in the Koa community and we need maintainers. If you're interested in fixing bugs or implementing new features feel free to open a pull request. We'll be adding active contributors as collaborators.
+
+Thanks to the original authors @alexmingoia and the original team for their great work.
+

src/Instancing/node_modules/@koa/router/history.md

+
+8.0.0 / 2019-06-16
+==================
+
+**others**
+  * [[`b5dd5e8`](http://github.com/koajs/koa-router/commit/b5dd5e8f00e841b7061a62ab6228cbe96a999470)] - chore: rename to @koa/router (dead-horse <<dead_horse@qq.com>>)
+
+-------------
+
+# Changelogs inherit from koa-router.
+
+## 7.4.0
+
+- Fix router.url() for multiple nested routers [#407](https://github.com/alexmingoia/koa-router/pull/407)
+- `layer.name` added to `ctx` at `ctx.routerName` during routing [#412](https://github.com/alexmingoia/koa-router/pull/412)
+- Router.use() was erroneously settings `(.*)` as a prefix to all routers nested with .use that did not pass an explicit prefix string as the first argument. This resulted in routes being matched that should not have been, included the running of multiple route handlers in error. [#369](https://github.com/alexmingoia/koa-router/issues/369) and [#410](https://github.com/alexmingoia/koa-router/issues/410) include information on this issue.
+
+## 7.3.0
+
+- Router#url() now accepts query parameters to add to generated urls [#396](https://github.com/alexmingoia/koa-router/pull/396)
+
+## 7.2.1
+
+- Respond to CORS preflights with 200, 0 length body [#359](https://github.com/alexmingoia/koa-router/issues/359)
+
+## 7.2.0
+
+- Fix a bug in Router#url and append Router object to ctx. [#350](https://github.com/alexmingoia/koa-router/pull/350)
+- Adds `_matchedRouteName` to context [#337](https://github.com/alexmingoia/koa-router/pull/337)
+- Respond to CORS preflights with 200, 0 length body [#359](https://github.com/alexmingoia/koa-router/issues/359)
+
+## 7.1.1
+
+- Fix bug where param handlers were run out of order [#282](https://github.com/alexmingoia/koa-router/pull/282)
+
+## 7.1.0
+
+- Backports: merge 5.4 work into the 7.x upstream. See 5.4.0 updates for more details.
+
+## 7.0.1
+
+- Fix: allowedMethods should be ctx.method not this.method [#215](https://github.com/alexmingoia/koa-router/pull/215)
+
+## 7.0.0
+
+- The API has changed to match the new promise-based middleware
+  signature of koa 2. See the
+  [koa 2.x readme](https://github.com/koajs/koa/tree/2.0.0-alpha.3) for more
+  information.
+- Middleware is now always run in the order declared by `.use()` (or `.get()`,
+  etc.), which matches Express 4 API.
+
+## 5.4.0
+
+- Expose matched route at `ctx._matchedRoute`.
+
+## 5.3.0
+
+- Register multiple routes with array of paths [#203](https://github.com/alexmingoia/koa-router/issue/143).
+- Improved router.url() [#143](https://github.com/alexmingoia/koa-router/pull/143)
+- Adds support for named routes and regular expressions
+  [#152](https://github.com/alexmingoia/koa-router/pull/152)
+- Add support for custom throw functions for 405 and 501 responses [#206](https://github.com/alexmingoia/koa-router/pull/206)
+
+## 5.2.3
+
+- Fix for middleware running twice when nesting routes [#184](https://github.com/alexmingoia/koa-router/issues/184)
+
+## 5.2.2
+
+- Register routes without params before those with params [#183](https://github.com/alexmingoia/koa-router/pull/183)
+- Fix for allowed methods [#182](https://github.com/alexmingoia/koa-router/issues/182)
+
+## 5.2.0
+
+- Add support for async/await. Resolves [#130](https://github.com/alexmingoia/koa-router/issues/130).
+- Add support for array of paths by Router#use(). Resolves [#175](https://github.com/alexmingoia/koa-router/issues/175).
+- Inherit param middleware when nesting routers. Fixes [#170](https://github.com/alexmingoia/koa-router/issues/170).
+- Default router middleware without path to root. Fixes [#161](https://github.com/alexmingoia/koa-router/issues/161), [#155](https://github.com/alexmingoia/koa-router/issues/155), [#156](https://github.com/alexmingoia/koa-router/issues/156).
+- Run nested router middleware after parent's. Fixes [#156](https://github.com/alexmingoia/koa-router/issues/156).
+- Remove dependency on koa-compose.
+
+## 5.1.1
+
+- Match routes in order they were defined. Fixes #131.
+
+## 5.1.0
+
+- Support mounting router middleware at a given path.
+
+## 5.0.1
+
+- Fix bug with missing parameters when nesting routers.
+
+## 5.0.0
+
+- Remove confusing API for extending koa app with router methods. Router#use()
+  does not have the same behavior as app#use().
+- Add support for nesting routes.
+- Remove support for regular expression routes to achieve nestable routers and
+  enable future trie-based routing optimizations.
+
+## 4.3.2
+
+- Do not send 405 if route matched but status is 404. Fixes #112, closes #114.
+
+## 4.3.1
+
+- Do not run middleware if not yielded to by previous middleware. Fixes #115.
+
+## 4.3.0
+
+- Add support for router prefixes.
+- Add MIT license.
+
+## 4.2.0
+
+- Fixed issue with router middleware being applied even if no route was
+matched.
+- Router.url - new static method to generate url from url pattern and data
+
+## 4.1.0
+
+Private API changed to separate context parameter decoration from route
+matching. `Router#match` and `Route#match` are now pure functions that return
+an array of routes that match the URL path.
+
+For modules using this private API that need to determine if a method and path
+match a route, `route.methods` must be checked against the routes returned from
+`router.match()`:
+
+```javascript
+var matchedRoute = router.match(path).filter(function (route) {
+  return ~route.methods.indexOf(method);
+}).shift();
+```
+
+## 4.0.0
+
+405, 501, and OPTIONS response handling was moved into separate middleware
+`router.allowedMethods()`. This resolves incorrect 501 or 405 responses when
+using multiple routers.
+
+### Breaking changes
+
+4.x is mostly backwards compatible with 3.x, except for the following:
+
+- Instantiating a router with `new` and `app` returns the router instance,
+  whereas 3.x returns the router middleware. When creating a router in 4.x, the
+  only time router middleware is returned is when creating using the
+  `Router(app)` signature (with `app` and without `new`).

src/Instancing/node_modules/@koa/router/lib/API_tpl.hbs

+
+## API Reference
+{{#module name="koa-router"~}}
+  {{>body~}}
+  {{>member-index~}}
+  {{>members~}}
+{{/module~}}

src/Instancing/node_modules/@koa/router/lib/layer.js

+var debug = require('debug')('koa-router');
+var pathToRegExp = require('path-to-regexp');
+var uri = require('urijs');
+
+module.exports = Layer;
+
+/**
+ * Initialize a new routing Layer with given `method`, `path`, and `middleware`.
+ *
+ * @param {String|RegExp} path Path string or regular expression.
+ * @param {Array} methods Array of HTTP verbs.
+ * @param {Array} middleware Layer callback/middleware or series of.
+ * @param {Object=} opts
+ * @param {String=} opts.name route name
+ * @param {String=} opts.sensitive case sensitive (default: false)
+ * @param {String=} opts.strict require the trailing slash (default: false)
+ * @returns {Layer}
+ * @private
+ */
+
+function Layer(path, methods, middleware, opts) {
+  this.opts = opts || {};
+  this.name = this.opts.name || null;
+  this.methods = [];
+  this.paramNames = [];
+  this.stack = Array.isArray(middleware) ? middleware : [middleware];
+
+  for(var i = 0; i < methods.length; i++) {
+    var l = this.methods.push(methods[i].toUpperCase());
+    if (this.methods[l-1] === 'GET') {
+       this.methods.unshift('HEAD');
+    }
+  }
+
+  // ensure middleware is a function
+  for (var i = 0; i < this.stack.length; i++) {
+    var fn = this.stack[i];
+    var type = (typeof fn);
+    if (type !== 'function') {
+      throw new Error(
+        methods.toString() + " `" + (this.opts.name || path) +"`: `middleware` "
+        + "must be a function, not `" + type + "`"
+      );
+    }
+  }
+
+  this.path = path;
+  this.regexp = pathToRegExp(path, this.paramNames, this.opts);
+
+  debug('defined route %s %s', this.methods, this.opts.prefix + this.path);
+};
+
+/**
+ * Returns whether request `path` matches route.
+ *
+ * @param {String} path
+ * @returns {Boolean}
+ * @private
+ */
+
+Layer.prototype.match = function (path) {
+  return this.regexp.test(path);
+};
+
+/**
+ * Returns map of URL parameters for given `path` and `paramNames`.
+ *
+ * @param {String} path
+ * @param {Array.<String>} captures
+ * @param {Object=} existingParams
+ * @returns {Object}
+ * @private
+ */
+
+Layer.prototype.params = function (path, captures, existingParams) {
+  var params = existingParams || {};
+
+  for (var len = captures.length, i=0; i<len; i++) {
+    if (this.paramNames[i]) {
+      var c = captures[i];
+      params[this.paramNames[i].name] = c ? safeDecodeURIComponent(c) : c;
+    }
+  }
+
+  return params;
+};
+
+/**
+ * Returns array of regexp url path captures.
+ *
+ * @param {String} path
+ * @returns {Array.<String>}
+ * @private
+ */
+
+Layer.prototype.captures = function (path) {
+  if (this.opts.ignoreCaptures) return [];
+  return path.match(this.regexp).slice(1);
+};
+
+/**
+ * Generate URL for route using given `params`.
+ *
+ * @example
+ *
+ * ```javascript
+ * const route = new Layer('/users/:id', ['GET'], fn);
+ *
+ * route.url({ id: 123 }); // => "/users/123"
+ * ```
+ *
+ * @param {Object} params url parameters
+ * @returns {String}
+ * @private
+ */
+
+Layer.prototype.url = function (params, options) {
+  var args = params;
+  var url = this.path.replace(/\(\.\*\)/g, '');
+  var toPath = pathToRegExp.compile(url);
+  var replaced;
+
+  if (typeof params != 'object') {
+    args = Array.prototype.slice.call(arguments);
+    if (typeof args[args.length - 1] == 'object') {
+      options = args[args.length - 1];
+      args = args.slice(0, args.length - 1);
+    }
+  }
+
+  var tokens = pathToRegExp.parse(url);
+  var replace = {};
+
+  if (args instanceof Array) {
+    for (var len = tokens.length, i=0, j=0; i<len; i++) {
+      if (tokens[i].name) replace[tokens[i].name] = args[j++];
+    }
+  } else if (tokens.some(token => token.name)) {
+    replace = params;
+  } else {
+    options = params;
+  }
+
+  replaced = toPath(replace);
+
+  if (options && options.query) {
+    var replaced = new uri(replaced)
+    replaced.search(options.query);
+    return replaced.toString();
+  }
+
+  return replaced;
+};
+
+/**
+ * Run validations on route named parameters.
+ *
+ * @example
+ *
+ * ```javascript
+ * router
+ *   .param('user', function (id, ctx, next) {
+ *     ctx.user = users[id];
+ *     if (!user) return ctx.status = 404;
+ *     next();
+ *   })
+ *   .get('/users/:user', function (ctx, next) {
+ *     ctx.body = ctx.user;
+ *   });
+ * ```
+ *
+ * @param {String} param
+ * @param {Function} middleware
+ * @returns {Layer}
+ * @private
+ */
+
+Layer.prototype.param = function (param, fn) {
+  var stack = this.stack;
+  var params = this.paramNames;
+  var middleware = function (ctx, next) {
+    return fn.call(this, ctx.params[param], ctx, next);
+  };
+  middleware.param = param;
+
+  var names = params.map(function (p) {
+    return p.name;
+  });
+
+  var x = names.indexOf(param);
+  if (x > -1) {
+    // iterate through the stack, to figure out where to place the handler fn
+    stack.some(function (fn, i) {
+      // param handlers are always first, so when we find an fn w/o a param property, stop here
+      // if the param handler at this part of the stack comes after the one we are adding, stop here
+      if (!fn.param || names.indexOf(fn.param) > x) {
+        // inject this param handler right before the current item
+        stack.splice(i, 0, middleware);
+        return true; // then break the loop
+      }
+    });
+  }
+
+  return this;
+};
+
+/**
+ * Prefix route path.
+ *
+ * @param {String} prefix
+ * @returns {Layer}
+ * @private
+ */
+
+Layer.prototype.setPrefix = function (prefix) {
+  if (this.path) {
+    this.path = prefix + this.path;
+    this.paramNames = [];
+    this.regexp = pathToRegExp(this.path, this.paramNames, this.opts);
+  }
+
+  return this;
+};
+
+/**
+ * Safe decodeURIComponent, won't throw any error.
+ * If `decodeURIComponent` error happen, just return the original value.
+ *
+ * @param {String} text
+ * @returns {String} URL decode original string.
+ * @private
+ */
+
+function safeDecodeURIComponent(text) {
+  try {
+    return decodeURIComponent(text);
+  } catch (e) {
+    return text;
+  }
+}

src/Instancing/node_modules/@koa/router/package.json

+{
+  "_from": "@koa/router@^8.0.8",
+  "_id": "@koa/router@8.0.8",
+  "_inBundle": false,
+  "_integrity": "sha512-FnT93N4NUehnXr+juupDmG2yfi0JnWdCmNEuIXpCG4TtG+9xvtrLambBH3RclycopVUOEYAim2lydiNBI7IRVg==",
+  "_location": "/@koa/router",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "@koa/router@^8.0.8",
+    "name": "@koa/router",
+    "escapedName": "@koa%2frouter",
+    "scope": "@koa",
+    "rawSpec": "^8.0.8",
+    "saveSpec": null,
+    "fetchSpec": "^8.0.8"
+  },
+  "_requiredBy": [
+    "/"
+  ],
+  "_resolved": "https://registry.npmjs.org/@koa/router/-/router-8.0.8.tgz",
+  "_shasum": "95f32d11373d03d89dcb63fabe9ac6f471095236",
+  "_spec": "@koa/router@^8.0.8",
+  "_where": "C:\\Users\\geova\\OneDrive\\Documents\\Unreal Projects\\VRClassroom 4.25\\src\\Instancing",
+  "author": {
+    "name": "Alex Mingoia",
+    "email": "talk@alexmingoia.com"
+  },
+  "bugs": {
+    "url": "https://github.com/koajs/router/issues",
+    "email": "niftylettuce@gmail.com"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "debug": "^4.1.1",
+    "http-errors": "^1.7.3",
+    "koa-compose": "^4.1.0",
+    "methods": "^1.1.2",
+    "path-to-regexp": "1.x",
+    "urijs": "^1.19.2"
+  },
+  "deprecated": false,
+  "description": "Router middleware for koa. Provides RESTful resource routing.",
+  "devDependencies": {
+    "expect.js": "^0.3.1",
+    "jsdoc-to-markdown": "^5.0.3",
+    "koa": "^2.11.0",
+    "mocha": "^6.2.2",
+    "should": "^13.2.3",
+    "supertest": "^4.0.2"
+  },
+  "engines": {
+    "node": ">= 8.0.0"
+  },
+  "files": [
+    "lib"
+  ],
+  "homepage": "https://github.com/koajs/router",
+  "keywords": [
+    "koa",
+    "middleware",
+    "route",
+    "router"
+  ],
+  "license": "MIT",
+  "main": "lib/router.js",
+  "name": "@koa/router",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/koajs/koa-router.git"
+  },
+  "scripts": {
+    "docs": "NODE_ENV=test jsdoc2md -t ./lib/API_tpl.hbs --src ./lib/*.js  >| API.md",
+    "test": "NODE_ENV=test mocha test/**/*.js"
+  },
+  "version": "8.0.8"
+}

src/Instancing/node_modules/@types/events/LICENSE

+    MIT License
+
+    Copyright (c) Microsoft Corporation. All rights reserved.
+
+    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

src/Instancing/node_modules/@types/events/README.md

+# Installation
+> `npm install --save @types/events`
+
+# Summary
+This package contains type definitions for events (https://github.com/Gozala/events).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/events
+
+Additional Details
+ * Last updated: Thu, 24 Jan 2019 03:19:08 GMT
+ * Dependencies: none
+ * Global values: none
+
+# Credits
+These definitions were written by Yasunori Ohoka <https://github.com/yasupeke>, Shenwei Wang <https://github.com/weareoutman>.

src/Instancing/node_modules/@types/events/index.d.ts

+// Type definitions for events 3.0
+// Project: https://github.com/Gozala/events
+// Definitions by: Yasunori Ohoka <https://github.com/yasupeke>
+//                 Shenwei Wang <https://github.com/weareoutman>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+export type Listener = (...args: any[]) => void;
+
+export class EventEmitter {
+  static listenerCount(emitter: EventEmitter, type: string | number): number;
+  static defaultMaxListeners: number;
+
+  eventNames(): Array<string | number>;
+  setMaxListeners(n: number): this;
+  getMaxListeners(): number;
+  emit(type: string | number, ...args: any[]): boolean;
+  addListener(type: string | number, listener: Listener): this;
+  on(type: string | number, listener: Listener): this;
+  once(type: string | number, listener: Listener): this;
+  prependListener(type: string | number, listener: Listener): this;
+  prependOnceListener(type: string | number, listener: Listener): this;
+  removeListener(type: string | number, listener: Listener): this;
+  off(type: string | number, listener: Listener): this;
+  removeAllListeners(type?: string | number): this;
+  listeners(type: string | number): Listener[];
+  listenerCount(type: string | number): number;
+  rawListeners(type: string | number): Listener[];
+}

src/Instancing/node_modules/@types/events/package.json

+{
+  "_from": "@types/events@*",
+  "_id": "@types/events@3.0.0",
+  "_inBundle": false,
+  "_integrity": "sha512-EaObqwIvayI5a8dCzhFrjKzVwKLxjoG9T6Ppd5CEo07LRKfQ8Yokw54r5+Wq7FaBQ+yXRvQAYPrHwya1/UFt9g==",
+  "_location": "/@types/events",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "@types/events@*",
+    "name": "@types/events",
+    "escapedName": "@types%2fevents",
+    "scope": "@types",
+    "rawSpec": "*",
+    "saveSpec": null,
+    "fetchSpec": "*"
+  },
+  "_requiredBy": [
+    "/@types/formidable"
+  ],
+  "_resolved": "https://registry.npmjs.org/@types/events/-/events-3.0.0.tgz",
+  "_shasum": "2862f3f58a9a7f7c3e78d79f130dd4d71c25c2a7",
+  "_spec": "@types/events@*",
+  "_where": "C:\\Users\\geova\\OneDrive\\Documents\\Unreal Projects\\VRClassroom 4.25\\src\\Instancing\\node_modules\\@types\\formidable",
+  "bugs": {
+    "url": "https://github.com/DefinitelyTyped/DefinitelyTyped/issues"
+  },
+  "bundleDependencies": false,
+  "contributors": [
+    {
+      "name": "Yasunori Ohoka",
+      "url": "https://github.com/yasupeke"
+    },
+    {
+      "name": "Shenwei Wang",
+      "url": "https://github.com/weareoutman"
+    }
+  ],
+  "dependencies": {},
+  "deprecated": false,
+  "description": "TypeScript definitions for events",
+  "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped#readme",
+  "license": "MIT",
+  "main": "",
+  "name": "@types/events",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DefinitelyTyped/DefinitelyTyped.git"
+  },
+  "scripts": {},
+  "typeScriptVersion": "2.0",
+  "types": "index",
+  "typesPublisherContentHash": "ae078136220837864b64cc7c1c5267ca1ceb809166fb74569e637bc7de9f2e12",
+  "version": "3.0.0"
+}

src/Instancing/node_modules/@types/formidable/LICENSE

+    MIT License
+
+    Copyright (c) Microsoft Corporation. All rights reserved.
+
+    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

src/Instancing/node_modules/@types/formidable/README.md

+# Installation
+> `npm install --save @types/formidable`
+
+# Summary
+This package contains type definitions for Formidable (https://github.com/felixge/node-formidable/).
+
+# Details
+Files were exported from https://www.github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/formidable
+
+Additional Details
+ * Last updated: Mon, 09 Apr 2018 17:46:20 GMT
+ * Dependencies: http, stream, events, node
+ * Global values: none
+
+# Credits
+These definitions were written by Wim Looman <https://github.com/Nemo157>.

src/Instancing/node_modules/@types/formidable/index.d.ts

+// Type definitions for Formidable 1.0.16
+// Project: https://github.com/felixge/node-formidable/
+// Definitions by: Wim Looman <https://github.com/Nemo157>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/// <reference types="node" />
+
+
+import http = require("http");
+import stream = require("stream");
+import events = require("events");
+
+export declare class IncomingForm extends events.EventEmitter {
+    encoding: string;
+    uploadDir: string;
+    keepExtensions: boolean;
+    maxFileSize: number;
+    maxFieldsSize: number;
+    maxFields: number;
+    hash: string | boolean;
+    multiples: boolean;
+    type: string;
+    bytesReceived: number;
+    bytesExpected: number;
+
+    onPart: (part: Part) => void;
+
+    handlePart(part: Part): void;
+    parse(req: http.IncomingMessage, callback?: (err: any, fields: Fields, files: Files) => any): void;
+}
+
+export interface Fields {
+    [key: string]: string|Array<string>;
+}
+
+export interface Files {
+    [key: string]: File; // | File[];
+}
+
+export interface Part extends stream.Stream {
+    headers: { [key: string]: string };
+    name: string;
+    filename?: string;
+    mime?: string;
+}
+
+export interface File {
+    size: number;
+    path: string;
+    name: string;
+    type: string;
+    lastModifiedDate?: Date;
+    hash?: string;
+
+    toJSON(): Object;
+}

src/Instancing/node_modules/@types/formidable/package.json

+{
+  "_from": "@types/formidable@^1.0.31",
+  "_id": "@types/formidable@1.0.31",
+  "_inBundle": false,
+  "_integrity": "sha512-dIhM5t8lRP0oWe2HF8MuPvdd1TpPTjhDMAqemcq6oIZQCBQTovhBAdTQ5L5veJB4pdQChadmHuxtB0YzqvfU3Q==",
+  "_location": "/@types/formidable",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "@types/formidable@^1.0.31",
+    "name": "@types/formidable",
+    "escapedName": "@types%2fformidable",
+    "scope": "@types",
+    "rawSpec": "^1.0.31",
+    "saveSpec": null,
+    "fetchSpec": "^1.0.31"
+  },
+  "_requiredBy": [
+    "/koa-body"
+  ],
+  "_resolved": "https://registry.npmjs.org/@types/formidable/-/formidable-1.0.31.tgz",
+  "_shasum": "274f9dc2d0a1a9ce1feef48c24ca0859e7ec947b",
+  "_spec": "@types/formidable@^1.0.31",
+  "_where": "C:\\Users\\geova\\OneDrive\\Documents\\Unreal Projects\\VRClassroom 4.25\\src\\Instancing\\node_modules\\koa-body",
+  "bugs": {
+    "url": "https://github.com/DefinitelyTyped/DefinitelyTyped/issues"
+  },
+  "bundleDependencies": false,
+  "contributors": [
+    {
+      "name": "Wim Looman",
+      "url": "https://github.com/Nemo157"
+    }
+  ],
+  "dependencies": {
+    "@types/events": "*",
+    "@types/node": "*"
+  },
+  "deprecated": false,
+  "description": "TypeScript definitions for Formidable",
+  "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped#readme",
+  "license": "MIT",
+  "main": "",
+  "name": "@types/formidable",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DefinitelyTyped/DefinitelyTyped.git"
+  },
+  "scripts": {},
+  "typeScriptVersion": "2.0",
+  "typesPublisherContentHash": "f25dea57419b31a9ce78e1d4cbcb2cd2044fc06f587b18cf269fc8e08aed9319",
+  "version": "1.0.31"
+}

src/Instancing/node_modules/@types/node/LICENSE

+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    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

src/Instancing/node_modules/@types/node/README.md

+# Installation
+> `npm install --save @types/node`
+
+# Summary
+This package contains type definitions for Node.js (http://nodejs.org/).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node.
+
+### Additional Details
+ * Last updated: Mon, 09 Nov 2020 19:41:27 GMT
+ * Dependencies: none
+ * Global values: `Buffer`, `__dirname`, `__filename`, `clearImmediate`, `clearInterval`, `clearTimeout`, `console`, `exports`, `global`, `module`, `process`, `queueMicrotask`, `require`, `setImmediate`, `setInterval`, `setTimeout`
+
+# Credits
+These definitions were written by [Microsoft TypeScript](https://github.com/Microsoft), [DefinitelyTyped](https://github.com/DefinitelyTyped), [Alberto Schiabel](https://github.com/jkomyno), [Alexander T.](https://github.com/a-tarasyuk), [Alvis HT Tang](https://github.com/alvis), [Andrew Makarov](https://github.com/r3nya), [Benjamin Toueg](https://github.com/btoueg), [Bruno Scheufler](https://github.com/brunoscheufler), [Chigozirim C.](https://github.com/smac89), [David Junger](https://github.com/touffy), [Deividas Bakanas](https://github.com/DeividasBakanas), [Eugene Y. Q. Shen](https://github.com/eyqs), [Flarna](https://github.com/Flarna), [Hannes Magnusson](https://github.com/Hannes-Magnusson-CK), [Hoàng Văn Khải](https://github.com/KSXGitHub), [Huw](https://github.com/hoo29), [Kelvin Jin](https://github.com/kjin), [Klaus Meinhardt](https://github.com/ajafff), [Lishude](https://github.com/islishude), [Mariusz Wiktorczyk](https://github.com/mwiktorczyk), [Mohsen Azimi](https://github.com/mohsen1), [Nicolas Even](https://github.com/n-e), [Nikita Galkin](https://github.com/galkin), [Parambir Singh](https://github.com/parambirs), [Sebastian Silbermann](https://github.com/eps1lon), [Simon Schick](https://github.com/SimonSchick), [Thomas den Hollander](https://github.com/ThomasdenH), [Wilco Bakker](https://github.com/WilcoBakker), [wwwy3y3](https://github.com/wwwy3y3), [Samuel Ainsworth](https://github.com/samuela), [Kyle Uehlein](https://github.com/kuehlein), [Jordi Oliveras Rovira](https://github.com/j-oliveras), [Thanik Bhongbhibhat](https://github.com/bhongy), [Marcin Kopacz](https://github.com/chyzwar), [Trivikram Kamat](https://github.com/trivikr), [Minh Son Nguyen](https://github.com/nguymin4), [Junxiao Shi](https://github.com/yoursunny), [Ilia Baryshnikov](https://github.com/qwelias), [ExE Boss](https://github.com/ExE-Boss), [Surasak Chaisurin](https://github.com/Ryan-Willpower), [Piotr Błażejewicz](https://github.com/peterblazejewicz), [Anna Henningsen](https://github.com/addaleax), [Jason Kwok](https://github.com/JasonHK), and [Victor Perin](https://github.com/victorperin).

src/Instancing/node_modules/@types/node/assert.d.ts

+declare module 'assert' {
+    /** An alias of `assert.ok()`. */
+    function assert(value: any, message?: string | Error): asserts value;
+    namespace assert {
+        class AssertionError implements Error {
+            name: string;
+            message: string;
+            actual: any;
+            expected: any;
+            operator: string;
+            generatedMessage: boolean;
+            code: 'ERR_ASSERTION';
+
+            constructor(options?: {
+                /** If provided, the error message is set to this value. */
+                message?: string;
+                /** The `actual` property on the error instance. */
+                actual?: any;
+                /** The `expected` property on the error instance. */
+                expected?: any;
+                /** The `operator` property on the error instance. */
+                operator?: string;
+                /** If provided, the generated stack trace omits frames before this function. */
+                stackStartFn?: Function;
+            });
+        }
+
+        class CallTracker {
+            calls(exact?: number): () => void;
+            calls<Func extends (...args: any[]) => any>(fn?: Func, exact?: number): Func;
+            report(): CallTrackerReportInformation[];
+            verify(): void;
+        }
+        interface CallTrackerReportInformation {
+            message: string;
+            /** The actual number of times the function was called. */
+            actual: number;
+            /** The number of times the function was expected to be called. */
+            expected: number;
+            /** The name of the function that is wrapped. */
+            operator: string;
+            /** A stack trace of the function. */
+            stack: object;
+        }
+
+        type AssertPredicate = RegExp | (new () => object) | ((thrown: any) => boolean) | object | Error;
+
+        function fail(message?: string | Error): never;
+        /** @deprecated since v10.0.0 - use fail([message]) or other assert functions instead. */
+        function fail(
+            actual: any,
+            expected: any,
+            message?: string | Error,
+            operator?: string,
+            stackStartFn?: Function,
+        ): never;
+        function ok(value: any, message?: string | Error): asserts value;
+        /** @deprecated since v9.9.0 - use strictEqual() instead. */
+        function equal(actual: any, expected: any, message?: string | Error): void;
+        /** @deprecated since v9.9.0 - use notStrictEqual() instead. */
+        function notEqual(actual: any, expected: any, message?: string | Error): void;
+        /** @deprecated since v9.9.0 - use deepStrictEqual() instead. */
+        function deepEqual(actual: any, expected: any, message?: string | Error): void;
+        /** @deprecated since v9.9.0 - use notDeepStrictEqual() instead. */
+        function notDeepEqual(actual: any, expected: any, message?: string | Error): void;
+        function strictEqual<T>(actual: any, expected: T, message?: string | Error): asserts actual is T;
+        function notStrictEqual(actual: any, expected: any, message?: string | Error): void;
+        function deepStrictEqual<T>(actual: any, expected: T, message?: string | Error): asserts actual is T;
+        function notDeepStrictEqual(actual: any, expected: any, message?: string | Error): void;
+
+        function throws(block: () => any, message?: string | Error): void;
+        function throws(block: () => any, error: AssertPredicate, message?: string | Error): void;
+        function doesNotThrow(block: () => any, message?: string | Error): void;
+        function doesNotThrow(block: () => any, error: RegExp | Function, message?: string | Error): void;
+
+        function ifError(value: any): asserts value is null | undefined;
+
+        function rejects(block: (() => Promise<any>) | Promise<any>, message?: string | Error): Promise<void>;
+        function rejects(
+            block: (() => Promise<any>) | Promise<any>,
+            error: AssertPredicate,
+            message?: string | Error,
+        ): Promise<void>;
+        function doesNotReject(block: (() => Promise<any>) | Promise<any>, message?: string | Error): Promise<void>;
+        function doesNotReject(
+            block: (() => Promise<any>) | Promise<any>,
+            error: RegExp | Function,
+            message?: string | Error,
+        ): Promise<void>;
+
+        function match(value: string, regExp: RegExp, message?: string | Error): void;
+        function doesNotMatch(value: string, regExp: RegExp, message?: string | Error): void;
+
+        const strict: Omit<
+            typeof assert,
+            | 'strict'
+            | 'deepEqual'
+            | 'notDeepEqual'
+            | 'equal'
+            | 'notEqual'
+            | 'ok'
+            | 'strictEqual'
+            | 'deepStrictEqual'
+            | 'ifError'
+        > & {
+            (value: any, message?: string | Error): asserts value;
+            strict: typeof strict;
+            deepEqual: typeof deepStrictEqual;
+            notDeepEqual: typeof notDeepStrictEqual;
+            equal: typeof strictEqual;
+            notEqual: typeof notStrictEqual;
+            ok(value: any, message?: string | Error): asserts value;
+            strictEqual<T>(actual: any, expected: T, message?: string | Error): asserts actual is T;
+            deepStrictEqual<T>(actual: any, expected: T, message?: string | Error): asserts actual is T;
+            ifError(value: any): asserts value is null | undefined;
+        };
+    }
+
+    export = assert;
+}

src/Instancing/node_modules/@types/node/async_hooks.d.ts

+/**
+ * Async Hooks module: https://nodejs.org/api/async_hooks.html
+ */
+declare module "async_hooks" {
+    /**
+     * Returns the asyncId of the current execution context.
+     */
+    function executionAsyncId(): number;
+
+    /**
+     * The resource representing the current execution.
+     *  Useful to store data within the resource.
+     *
+     * Resource objects returned by `executionAsyncResource()` are most often internal
+     * Node.js handle objects with undocumented APIs. Using any functions or properties
+     * on the object is likely to crash your application and should be avoided.
+     *
+     * Using `executionAsyncResource()` in the top-level execution context will
+     * return an empty object as there is no handle or request object to use,
+     * but having an object representing the top-level can be helpful.
+     */
+    function executionAsyncResource(): object;
+
+    /**
+     * Returns the ID of the resource responsible for calling the callback that is currently being executed.
+     */
+    function triggerAsyncId(): number;
+
+    interface HookCallbacks {
+        /**
+         * Called when a class is constructed that has the possibility to emit an asynchronous event.
+         * @param asyncId a unique ID for the async resource
+         * @param type the type of the async resource
+         * @param triggerAsyncId the unique ID of the async resource in whose execution context this async resource was created
+         * @param resource reference to the resource representing the async operation, needs to be released during destroy
+         */
+        init?(asyncId: number, type: string, triggerAsyncId: number, resource: object): void;
+
+        /**
+         * When an asynchronous operation is initiated or completes a callback is called to notify the user.
+         * The before callback is called just before said callback is executed.
+         * @param asyncId the unique identifier assigned to the resource about to execute the callback.
+         */
+        before?(asyncId: number): void;
+
+        /**
+         * Called immediately after the callback specified in before is completed.
+         * @param asyncId the unique identifier assigned to the resource which has executed the callback.
+         */
+        after?(asyncId: number): void;
+
+        /**
+         * Called when a promise has resolve() called. This may not be in the same execution id
+         * as the promise itself.
+         * @param asyncId the unique id for the promise that was resolve()d.
+         */
+        promiseResolve?(asyncId: number): void;
+
+        /**
+         * Called after the resource corresponding to asyncId is destroyed
+         * @param asyncId a unique ID for the async resource
+         */
+        destroy?(asyncId: number): void;
+    }
+
+    interface AsyncHook {
+        /**
+         * Enable the callbacks for a given AsyncHook instance. If no callbacks are provided enabling is a noop.
+         */
+        enable(): this;
+
+        /**
+         * Disable the callbacks for a given AsyncHook instance from the global pool of AsyncHook callbacks to be executed. Once a hook has been disabled it will not be called again until enabled.
+         */
+        disable(): this;
+    }
+
+    /**
+     * Registers functions to be called for different lifetime events of each async operation.
+     * @param options the callbacks to register
+     * @return an AsyncHooks instance used for disabling and enabling hooks
+     */
+    function createHook(options: HookCallbacks): AsyncHook;
+
+    interface AsyncResourceOptions {
+      /**
+       * The ID of the execution context that created this async event.
+       * Default: `executionAsyncId()`
+       */
+      triggerAsyncId?: number;
+
+      /**
+       * Disables automatic `emitDestroy` when the object is garbage collected.
+       * This usually does not need to be set (even if `emitDestroy` is called
+       * manually), unless the resource's `asyncId` is retrieved and the
+       * sensitive API's `emitDestroy` is called with it.
+       * Default: `false`
+       */
+      requireManualDestroy?: boolean;
+    }
+
+    /**
+     * The class AsyncResource was designed to be extended by the embedder's async resources.
+     * Using this users can easily trigger the lifetime events of their own resources.
+     */
+    class AsyncResource {
+        /**
+         * AsyncResource() is meant to be extended. Instantiating a
+         * new AsyncResource() also triggers init. If triggerAsyncId is omitted then
+         * async_hook.executionAsyncId() is used.
+         * @param type The type of async event.
+         * @param triggerAsyncId The ID of the execution context that created
+         *   this async event (default: `executionAsyncId()`), or an
+         *   AsyncResourceOptions object (since 9.3)
+         */
+        constructor(type: string, triggerAsyncId?: number|AsyncResourceOptions);
+
+        /**
+         * Binds the given function to the current execution context.
+         * @param fn The function to bind to the current execution context.
+         * @param type An optional name to associate with the underlying `AsyncResource`.
+         */
+        static bind<Func extends (...args: any[]) => any>(fn: Func, type?: string): Func & { asyncResource: AsyncResource };
+
+        /**
+         * Binds the given function to execute to this `AsyncResource`'s scope.
+         * @param fn The function to bind to the current `AsyncResource`.
+         */
+        bind<Func extends (...args: any[]) => any>(fn: Func): Func & { asyncResource: AsyncResource };
+
+        /**
+         * Call the provided function with the provided arguments in the
+         * execution context of the async resource. This will establish the
+         * context, trigger the AsyncHooks before callbacks, call the function,
+         * trigger the AsyncHooks after callbacks, and then restore the original
+         * execution context.
+         * @param fn The function to call in the execution context of this
+         *   async resource.
+         * @param thisArg The receiver to be used for the function call.
+         * @param args Optional arguments to pass to the function.
+         */
+        runInAsyncScope<This, Result>(fn: (this: This, ...args: any[]) => Result, thisArg?: This, ...args: any[]): Result;
+
+        /**
+         * Call AsyncHooks destroy callbacks.
+         */
+        emitDestroy(): void;
+
+        /**
+         * @return the unique ID assigned to this AsyncResource instance.
+         */
+        asyncId(): number;
+
+        /**
+         * @return the trigger ID for this AsyncResource instance.
+         */
+        triggerAsyncId(): number;
+    }
+
+    /**
+     * When having multiple instances of `AsyncLocalStorage`, they are independent
+     * from each other. It is safe to instantiate this class multiple times.
+     */
+    class AsyncLocalStorage<T> {
+        /**
+         * This method disables the instance of `AsyncLocalStorage`. All subsequent calls
+         * to `asyncLocalStorage.getStore()` will return `undefined` until
+         * `asyncLocalStorage.run()` is called again.
+         *
+         * When calling `asyncLocalStorage.disable()`, all current contexts linked to the
+         * instance will be exited.
+         *
+         * Calling `asyncLocalStorage.disable()` is required before the
+         * `asyncLocalStorage` can be garbage collected. This does not apply to stores
+         * provided by the `asyncLocalStorage`, as those objects are garbage collected
+         * along with the corresponding async resources.
+         *
+         * This method is to be used when the `asyncLocalStorage` is not in use anymore
+         * in the current process.
+         */
+        disable(): void;
+
+        /**
+         * This method returns the current store. If this method is called outside of an
+         * asynchronous context initialized by calling `asyncLocalStorage.run`, it will
+         * return `undefined`.
+         */
+        getStore(): T | undefined;
+
+        /**
+         * This methods runs a function synchronously within a context and return its
+         * return value. The store is not accessible outside of the callback function or
+         * the asynchronous operations created within the callback.
+         *
+         * Optionally, arguments can be passed to the function. They will be passed to the
+         * callback function.
+         *
+         * I the callback function throws an error, it will be thrown by `run` too. The
+         * stacktrace will not be impacted by this call and the context will be exited.
+         */
+        // TODO: Apply generic vararg once available
+        run<R>(store: T, callback: (...args: any[]) => R, ...args: any[]): R;
+
+        /**
+         * This methods runs a function synchronously outside of a context and return its
+         * return value. The store is not accessible within the callback function or the
+         * asynchronous operations created within the callback.
+         *
+         * Optionally, arguments can be passed to the function. They will be passed to the
+         * callback function.
+         *
+         * If the callback function throws an error, it will be thrown by `exit` too. The
+         * stacktrace will not be impacted by this call and the context will be
+         * re-entered.
+         */
+        // TODO: Apply generic vararg once available
+        exit<R>(callback: (...args: any[]) => R, ...args: any[]): R;
+
+        /**
+         * Calling `asyncLocalStorage.enterWith(store)` will transition into the context
+         * for the remainder of the current synchronous execution and will persist
+         * through any following asynchronous calls.
+         */
+        enterWith(store: T): void;
+    }
+}

src/Instancing/node_modules/@types/node/base.d.ts

+// NOTE: These definitions support NodeJS and TypeScript 3.7.
+
+// NOTE: TypeScript version-specific augmentations can be found in the following paths:
+//          - ~/base.d.ts         - Shared definitions common to all TypeScript versions
+//          - ~/index.d.ts        - Definitions specific to TypeScript 2.1
+//          - ~/ts3.7/base.d.ts   - Definitions specific to TypeScript 3.7
+//          - ~/ts3.7/index.d.ts  - Definitions specific to TypeScript 3.7 with assert pulled in
+
+// Reference required types from the default lib:
+/// <reference lib="es2018" />
+/// <reference lib="esnext.asynciterable" />
+/// <reference lib="esnext.intl" />
+/// <reference lib="esnext.bigint" />
+
+// Base definitions for all NodeJS modules that are not specific to any version of TypeScript:
+/// <reference path="ts3.6/base.d.ts" />
+
+// TypeScript 3.7-specific augmentations:
+/// <reference path="assert.d.ts" />

src/Instancing/node_modules/@types/node/buffer.d.ts

+declare module "buffer" {
+    export const INSPECT_MAX_BYTES: number;
+    export const kMaxLength: number;
+    export const kStringMaxLength: number;
+    export const constants: {
+        MAX_LENGTH: number;
+        MAX_STRING_LENGTH: number;
+    };
+    const BuffType: typeof Buffer;
+
+    export type TranscodeEncoding = "ascii" | "utf8" | "utf16le" | "ucs2" | "latin1" | "binary";
+
+    export function transcode(source: Uint8Array, fromEnc: TranscodeEncoding, toEnc: TranscodeEncoding): Buffer;
+
+    export const SlowBuffer: {
+        /** @deprecated since v6.0.0, use `Buffer.allocUnsafeSlow()` */
+        new(size: number): Buffer;
+        prototype: Buffer;
+    };
+
+    export { BuffType as Buffer };
+}

src/Instancing/node_modules/@types/node/console.d.ts

+declare module "console" {
+    import { InspectOptions } from 'util';
+
+    global {
+        // This needs to be global to avoid TS2403 in case lib.dom.d.ts is present in the same build
+        interface Console {
+            Console: NodeJS.ConsoleConstructor;
+            /**
+             * A simple assertion test that verifies whether `value` is truthy.
+             * If it is not, an `AssertionError` is thrown.
+             * If provided, the error `message` is formatted using `util.format()` and used as the error message.
+             */
+            assert(value: any, message?: string, ...optionalParams: any[]): void;
+            /**
+             * When `stdout` is a TTY, calling `console.clear()` will attempt to clear the TTY.
+             * When `stdout` is not a TTY, this method does nothing.
+             */
+            clear(): void;
+            /**
+             * Maintains an internal counter specific to `label` and outputs to `stdout` the number of times `console.count()` has been called with the given `label`.
+             */
+            count(label?: string): void;
+            /**
+             * Resets the internal counter specific to `label`.
+             */
+            countReset(label?: string): void;
+            /**
+             * The `console.debug()` function is an alias for {@link console.log()}.
+             */
+            debug(message?: any, ...optionalParams: any[]): void;
+            /**
+             * Uses {@link util.inspect()} on `obj` and prints the resulting string to `stdout`.
+             * This function bypasses any custom `inspect()` function defined on `obj`.
+             */
+            dir(obj: any, options?: InspectOptions): void;
+            /**
+             * This method calls {@link console.log()} passing it the arguments received. Please note that this method does not produce any XML formatting
+             */
+            dirxml(...data: any[]): void;
+            /**
+             * Prints to `stderr` with newline.
+             */
+            error(message?: any, ...optionalParams: any[]): void;
+            /**
+             * Increases indentation of subsequent lines by two spaces.
+             * If one or more `label`s are provided, those are printed first without the additional indentation.
+             */
+            group(...label: any[]): void;
+            /**
+             * The `console.groupCollapsed()` function is an alias for {@link console.group()}.
+             */
+            groupCollapsed(...label: any[]): void;
+            /**
+             * Decreases indentation of subsequent lines by two spaces.
+             */
+            groupEnd(): void;
+            /**
+             * The {@link console.info()} function is an alias for {@link console.log()}.
+             */
+            info(message?: any, ...optionalParams: any[]): void;
+            /**
+             * Prints to `stdout` with newline.
+             */
+            log(message?: any, ...optionalParams: any[]): void;
+            /**
+             * This method does not display anything unless used in the inspector.
+             *  Prints to `stdout` the array `array` formatted as a table.
+             */
+            table(tabularData: any, properties?: ReadonlyArray<string>): void;
+            /**
+             * Starts a timer that can be used to compute the duration of an operation. Timers are identified by a unique `label`.
+             */
+            time(label?: string): void;
+            /**
+             * Stops a timer that was previously started by calling {@link console.time()} and prints the result to `stdout`.
+             */
+            timeEnd(label?: string): void;
+            /**
+             * For a timer that was previously started by calling {@link console.time()}, prints the elapsed time and other `data` arguments to `stdout`.
+             */
+            timeLog(label?: string, ...data: any[]): void;
+            /**
+             * Prints to `stderr` the string 'Trace :', followed by the {@link util.format()} formatted message and stack trace to the current position in the code.
+             */
+            trace(message?: any, ...optionalParams: any[]): void;
+            /**
+             * The {@link console.warn()} function is an alias for {@link console.error()}.
+             */
+            warn(message?: any, ...optionalParams: any[]): void;
+
+            // --- Inspector mode only ---
+            /**
+             * This method does not display anything unless used in the inspector.
+             *  Starts a JavaScript CPU profile with an optional label.
+             */
+            profile(label?: string): void;
+            /**
+             * This method does not display anything unless used in the inspector.
+             *  Stops the current JavaScript CPU profiling session if one has been started and prints the report to the Profiles panel of the inspector.
+             */
+            profileEnd(label?: string): void;
+            /**
+             * This method does not display anything unless used in the inspector.
+             *  Adds an event with the label `label` to the Timeline panel of the inspector.
+             */
+            timeStamp(label?: string): void;
+        }
+
+        var console: Console;
+
+        namespace NodeJS {
+            interface ConsoleConstructorOptions {
+                stdout: WritableStream;
+                stderr?: WritableStream;
+                ignoreErrors?: boolean;
+                colorMode?: boolean | 'auto';
+                inspectOptions?: InspectOptions;
+            }
+
+            interface ConsoleConstructor {
+                prototype: Console;
+                new(stdout: WritableStream, stderr?: WritableStream, ignoreErrors?: boolean): Console;
+                new(options: ConsoleConstructorOptions): Console;
+            }
+
+            interface Global {
+                console: typeof console;
+            }
+        }
+    }
+
+    export = console;
+}

src/Instancing/node_modules/@types/node/constants.d.ts

+/** @deprecated since v6.3.0 - use constants property exposed by the relevant module instead. */
+declare module "constants" {
+    import { constants as osConstants, SignalConstants } from 'os';
+    import { constants as cryptoConstants } from 'crypto';
+    import { constants as fsConstants } from 'fs';
+    const exp: typeof osConstants.errno & typeof osConstants.priority & SignalConstants & typeof cryptoConstants & typeof fsConstants;
+    export = exp;
+}

src/Instancing/node_modules/@types/node/dgram.d.ts

+declare module "dgram" {
+    import { AddressInfo } from "net";
+    import * as dns from "dns";
+    import * as events from "events";
+
+    interface RemoteInfo {
+        address: string;
+        family: 'IPv4' | 'IPv6';
+        port: number;
+        size: number;
+    }
+
+    interface BindOptions {
+        port?: number;
+        address?: string;
+        exclusive?: boolean;
+        fd?: number;
+    }
+
+    type SocketType = "udp4" | "udp6";
+
+    interface SocketOptions {
+        type: SocketType;
+        reuseAddr?: boolean;
+        /**
+         * @default false
+         */
+        ipv6Only?: boolean;
+        recvBufferSize?: number;
+        sendBufferSize?: number;
+        lookup?: (hostname: string, options: dns.LookupOneOptions, callback: (err: NodeJS.ErrnoException | null, address: string, family: number) => void) => void;
+    }
+
+    function createSocket(type: SocketType, callback?: (msg: Buffer, rinfo: RemoteInfo) => void): Socket;
+    function createSocket(options: SocketOptions, callback?: (msg: Buffer, rinfo: RemoteInfo) => void): Socket;
+
+    class Socket extends events.EventEmitter {
+        addMembership(multicastAddress: string, multicastInterface?: string): void;
+        address(): AddressInfo;
+        bind(port?: number, address?: string, callback?: () => void): void;
+        bind(port?: number, callback?: () => void): void;
+        bind(callback?: () => void): void;
+        bind(options: BindOptions, callback?: () => void): void;
+        close(callback?: () => void): void;
+        connect(port: number, address?: string, callback?: () => void): void;
+        connect(port: number, callback: () => void): void;
+        disconnect(): void;
+        dropMembership(multicastAddress: string, multicastInterface?: string): void;
+        getRecvBufferSize(): number;
+        getSendBufferSize(): number;
+        ref(): this;
+        remoteAddress(): AddressInfo;
+        send(msg: string | Uint8Array | ReadonlyArray<any>, port?: number, address?: string, callback?: (error: Error | null, bytes: number) => void): void;
+        send(msg: string | Uint8Array | ReadonlyArray<any>, port?: number, callback?: (error: Error | null, bytes: number) => void): void;
+        send(msg: string | Uint8Array | ReadonlyArray<any>, callback?: (error: Error | null, bytes: number) => void): void;
+        send(msg: string | Uint8Array, offset: number, length: number, port?: number, address?: string, callback?: (error: Error | null, bytes: number) => void): void;
+        send(msg: string | Uint8Array, offset: number, length: number, port?: number, callback?: (error: Error | null, bytes: number) => void): void;
+        send(msg: string | Uint8Array, offset: number, length: number, callback?: (error: Error | null, bytes: number) => void): void;
+        setBroadcast(flag: boolean): void;
+        setMulticastInterface(multicastInterface: string): void;
+        setMulticastLoopback(flag: boolean): void;
+        setMulticastTTL(ttl: number): void;
+        setRecvBufferSize(size: number): void;
+        setSendBufferSize(size: number): void;
+        setTTL(ttl: number): void;
+        unref(): this;
+        /**
+         * Tells the kernel to join a source-specific multicast channel at the given
+         * `sourceAddress` and `groupAddress`, using the `multicastInterface` with the
+         * `IP_ADD_SOURCE_MEMBERSHIP` socket option.
+         * If the `multicastInterface` argument
+         * is not specified, the operating system will choose one interface and will add
+         * membership to it.
+         * To add membership to every available interface, call
+         * `socket.addSourceSpecificMembership()` multiple times, once per interface.
+         */
+        addSourceSpecificMembership(sourceAddress: string, groupAddress: string, multicastInterface?: string): void;
+
+        /**
+         * Instructs the kernel to leave a source-specific multicast channel at the given
+         * `sourceAddress` and `groupAddress` using the `IP_DROP_SOURCE_MEMBERSHIP`
+         * socket option. This method is automatically called by the kernel when the
+         * socket is closed or the process terminates, so most apps will never have
+         * reason to call this.
+         *
+         * If `multicastInterface` is not specified, the operating system will attempt to
+         * drop membership on all valid interfaces.
+         */
+        dropSourceSpecificMembership(sourceAddress: string, groupAddress: string, multicastInterface?: string): void;
+
+        /**
+         * events.EventEmitter
+         * 1. close
+         * 2. connect
+         * 3. error
+         * 4. listening
+         * 5. message
+         */
+        addListener(event: string, listener: (...args: any[]) => void): this;
+        addListener(event: "close", listener: () => void): this;
+        addListener(event: "connect", listener: () => void): this;
+        addListener(event: "error", listener: (err: Error) => void): this;
+        addListener(event: "listening", listener: () => void): this;
+        addListener(event: "message", listener: (msg: Buffer, rinfo: RemoteInfo) => void): this;
+
+        emit(event: string | symbol, ...args: any[]): boolean;
+        emit(event: "close"): boolean;
+        emit(event: "connect"): boolean;
+        emit(event: "error", err: Error): boolean;
+        emit(event: "listening"): boolean;
+        emit(event: "message", msg: Buffer, rinfo: RemoteInfo): boolean;
+
+        on(event: string, listener: (...args: any[]) => void): this;
+        on(event: "close", listener: () => void): this;
+        on(event: "connect", listener: () => void): this;
+        on(event: "error", listener: (err: Error) => void): this;
+        on(event: "listening", listener: () => void): this;
+        on(event: "message", listener: (msg: Buffer, rinfo: RemoteInfo) => void): this;
+
+        once(event: string, listener: (...args: any[]) => void): this;
+        once(event: "close", listener: () => void): this;
+        once(event: "connect", listener: () => void): this;
+        once(event: "error", listener: (err: Error) => void): this;
+        once(event: "listening", listener: () => void): this;
+        once(event: "message", listener: (msg: Buffer, rinfo: RemoteInfo) => void): this;
+
+        prependListener(event: string, listener: (...args: any[]) => void): this;
+        prependListener(event: "close", listener: () => void): this;
+        prependListener(event: "connect", listener: () => void): this;
+        prependListener(event: "error", listener: (err: Error) => void): this;
+        prependListener(event: "listening", listener: () => void): this;
+        prependListener(event: "message", listener: (msg: Buffer, rinfo: RemoteInfo) => void): this;
+
+        prependOnceListener(event: string, listener: (...args: any[]) => void): this;
+        prependOnceListener(event: "close", listener: () => void): this;
+        prependOnceListener(event: "connect", listener: () => void): this;
+        prependOnceListener(event: "error", listener: (err: Error) => void): this;
+        prependOnceListener(event: "listening", listener: () => void): this;
+        prependOnceListener(event: "message", listener: (msg: Buffer, rinfo: RemoteInfo) => void): this;
+    }
+}

src/Instancing/node_modules/@types/node/domain.d.ts

+declare module "domain" {
+    import { EventEmitter } from "events";
+
+    global {
+        namespace NodeJS {
+            interface Domain extends EventEmitter {
+                run<T>(fn: (...args: any[]) => T, ...args: any[]): T;
+                add(emitter: EventEmitter | Timer): void;
+                remove(emitter: EventEmitter | Timer): void;
+                bind<T extends Function>(cb: T): T;
+                intercept<T extends Function>(cb: T): T;
+            }
+        }
+    }
+
+    interface Domain extends NodeJS.Domain {}
+    class Domain extends EventEmitter {
+        members: Array<EventEmitter | NodeJS.Timer>;
+        enter(): void;
+        exit(): void;
+    }
+
+    function create(): Domain;
+}

src/Instancing/node_modules/@types/node/events.d.ts

+declare module "events" {
+    interface EventEmitterOptions {
+        /**
+         * Enables automatic capturing of promise rejection.
+         */
+        captureRejections?: boolean;
+    }
+
+    interface NodeEventTarget {
+        once(event: string | symbol, listener: (...args: any[]) => void): this;
+    }
+
+    interface DOMEventTarget {
+        addEventListener(event: string, listener: (...args: any[]) => void, opts?: { once: boolean }): any;
+    }
+
+    namespace EventEmitter {
+        function once(emitter: NodeEventTarget, event: string | symbol): Promise<any[]>;
+        function once(emitter: DOMEventTarget, event: string): Promise<any[]>;
+        function on(emitter: EventEmitter, event: string): AsyncIterableIterator<any>;
+        const captureRejectionSymbol: unique symbol;
+
+        /**
+         * This symbol shall be used to install a listener for only monitoring `'error'`
+         * events. Listeners installed using this symbol are called before the regular
+         * `'error'` listeners are called.
+         *
+         * Installing a listener using this symbol does not change the behavior once an
+         * `'error'` event is emitted, therefore the process will still crash if no
+         * regular `'error'` listener is installed.
+         */
+        const errorMonitor: unique symbol;
+        /**
+         * Sets or gets the default captureRejection value for all emitters.
+         */
+        let captureRejections: boolean;
+
+        interface EventEmitter extends NodeJS.EventEmitter {
+        }
+
+        class EventEmitter {
+            constructor(options?: EventEmitterOptions);
+            /** @deprecated since v4.0.0 */
+            static listenerCount(emitter: EventEmitter, event: string | symbol): number;
+            static defaultMaxListeners: number;
+            /**
+             * This symbol shall be used to install a listener for only monitoring `'error'`
+             * events. Listeners installed using this symbol are called before the regular
+             * `'error'` listeners are called.
+             *
+             * Installing a listener using this symbol does not change the behavior once an
+             * `'error'` event is emitted, therefore the process will still crash if no
+             * regular `'error'` listener is installed.
+             */
+            static readonly errorMonitor: unique symbol;
+        }
+    }
+
+    global {
+        namespace NodeJS {
+            interface EventEmitter {
+                addListener(event: string | symbol, listener: (...args: any[]) => void): this;
+                on(event: string | symbol, listener: (...args: any[]) => void): this;
+                once(event: string | symbol, listener: (...args: any[]) => void): this;
+                removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
+                off(event: string | symbol, listener: (...args: any[]) => void): this;
+                removeAllListeners(event?: string | symbol): this;
+                setMaxListeners(n: number): this;
+                getMaxListeners(): number;
+                listeners(event: string | symbol): Function[];
+                rawListeners(event: string | symbol): Function[];
+                emit(event: string | symbol, ...args: any[]): boolean;
+                listenerCount(event: string | symbol): number;
+                // Added in Node 6...
+                prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
+                prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
+                eventNames(): Array<string | symbol>;
+            }
+        }
+    }
+
+    export = EventEmitter;
+}

src/Instancing/node_modules/@types/node/globals.global.d.ts

+declare var global: NodeJS.Global & typeof globalThis;

src/Instancing/node_modules/@types/node/https.d.ts

+declare module "https" {
+    import * as tls from "tls";
+    import * as events from "events";
+    import * as http from "http";
+    import { URL } from "url";
+
+    type ServerOptions = tls.SecureContextOptions & tls.TlsOptions & http.ServerOptions;
+
+    type RequestOptions = http.RequestOptions & tls.SecureContextOptions & {
+        rejectUnauthorized?: boolean; // Defaults to true
+        servername?: string; // SNI TLS Extension
+    };
+
+    interface AgentOptions extends http.AgentOptions, tls.ConnectionOptions {
+        rejectUnauthorized?: boolean;
+        maxCachedSessions?: number;
+    }
+
+    class Agent extends http.Agent {
+        constructor(options?: AgentOptions);
+        options: AgentOptions;
+    }
+
+    interface Server extends http.HttpBase {}
+    class Server extends tls.Server {
+        constructor(requestListener?: http.RequestListener);
+        constructor(options: ServerOptions, requestListener?: http.RequestListener);
+    }
+
+    function createServer(requestListener?: http.RequestListener): Server;
+    function createServer(options: ServerOptions, requestListener?: http.RequestListener): Server;
+    function request(options: RequestOptions | string | URL, callback?: (res: http.IncomingMessage) => void): http.ClientRequest;
+    function request(url: string | URL, options: RequestOptions, callback?: (res: http.IncomingMessage) => void): http.ClientRequest;
+    function get(options: RequestOptions | string | URL, callback?: (res: http.IncomingMessage) => void): http.ClientRequest;
+    function get(url: string | URL, options: RequestOptions, callback?: (res: http.IncomingMessage) => void): http.ClientRequest;
+    let globalAgent: Agent;
+}

src/Instancing/node_modules/@types/node/index.d.ts

+// Type definitions for non-npm package Node.js 14.14
+// Project: http://nodejs.org/
+// Definitions by: Microsoft TypeScript <https://github.com/Microsoft>
+//                 DefinitelyTyped <https://github.com/DefinitelyTyped>
+//                 Alberto Schiabel <https://github.com/jkomyno>
+//                 Alexander T. <https://github.com/a-tarasyuk>
+//                 Alvis HT Tang <https://github.com/alvis>
+//                 Andrew Makarov <https://github.com/r3nya>
+//                 Benjamin Toueg <https://github.com/btoueg>
+//                 Bruno Scheufler <https://github.com/brunoscheufler>
+//                 Chigozirim C. <https://github.com/smac89>
+//                 David Junger <https://github.com/touffy>
+//                 Deividas Bakanas <https://github.com/DeividasBakanas>
+//                 Eugene Y. Q. Shen <https://github.com/eyqs>
+//                 Flarna <https://github.com/Flarna>
+//                 Hannes Magnusson <https://github.com/Hannes-Magnusson-CK>
+//                 Hoàng Văn Khải <https://github.com/KSXGitHub>
+//                 Huw <https://github.com/hoo29>
+//                 Kelvin Jin <https://github.com/kjin>
+//                 Klaus Meinhardt <https://github.com/ajafff>
+//                 Lishude <https://github.com/islishude>
+//                 Mariusz Wiktorczyk <https://github.com/mwiktorczyk>
+//                 Mohsen Azimi <https://github.com/mohsen1>
+//                 Nicolas Even <https://github.com/n-e>
+//                 Nikita Galkin <https://github.com/galkin>
+//                 Parambir Singh <https://github.com/parambirs>
+//                 Sebastian Silbermann <https://github.com/eps1lon>
+//                 Simon Schick <https://github.com/SimonSchick>
+//                 Thomas den Hollander <https://github.com/ThomasdenH>
+//                 Wilco Bakker <https://github.com/WilcoBakker>
+//                 wwwy3y3 <https://github.com/wwwy3y3>
+//                 Samuel Ainsworth <https://github.com/samuela>
+//                 Kyle Uehlein <https://github.com/kuehlein>
+//                 Jordi Oliveras Rovira <https://github.com/j-oliveras>
+//                 Thanik Bhongbhibhat <https://github.com/bhongy>
+//                 Marcin Kopacz <https://github.com/chyzwar>
+//                 Trivikram Kamat <https://github.com/trivikr>
+//                 Minh Son Nguyen <https://github.com/nguymin4>
+//                 Junxiao Shi <https://github.com/yoursunny>
+//                 Ilia Baryshnikov <https://github.com/qwelias>
+//                 ExE Boss <https://github.com/ExE-Boss>
+//                 Surasak Chaisurin <https://github.com/Ryan-Willpower>
+//                 Piotr Błażejewicz <https://github.com/peterblazejewicz>
+//                 Anna Henningsen <https://github.com/addaleax>
+//                 Jason Kwok <https://github.com/JasonHK>
+//                 Victor Perin <https://github.com/victorperin>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+// NOTE: These definitions support NodeJS and TypeScript 3.7.
+// Typically type modifications should be made in base.d.ts instead of here
+
+/// <reference path="base.d.ts" />
+
+// NOTE: TypeScript version-specific augmentations can be found in the following paths:
+//          - ~/base.d.ts         - Shared definitions common to all TypeScript versions
+//          - ~/index.d.ts        - Definitions specific to TypeScript 2.8
+//          - ~/ts3.5/index.d.ts  - Definitions specific to TypeScript 3.5
+
+// NOTE: Augmentations for TypeScript 3.5 and later should use individual files for overrides
+//       within the respective ~/ts3.5 (or later) folder. However, this is disallowed for versions
+//       prior to TypeScript 3.5, so the older definitions will be found here.

src/Instancing/node_modules/@types/node/ts3.4/globals.global.d.ts

+declare var global: NodeJS.Global;

src/Instancing/node_modules/any-promise/implementation.js

+module.exports = require('./register')().implementation

src/Instancing/node_modules/any-promise/index.js

+module.exports = require('./register')().Promise