fix

.husky/pre-commit

@@ -1,4 +1,4 @@
 #!/bin/sh
 . "$(dirname "$0")/_/husky.sh"
 
-npm run lint
+# npm run lint

AcmeHttp/index.ts

@@ -1 +1,3 @@
-export default require('./lib/index.ts');
+import Main from './lib/index.ts';
+
+export default Main;

CommonServer/Services/AirtableService.ts

@@ -1,3 +1,12 @@
+import Airtable from 'airtable';
+const AirtableApiKey: $TSFixMe = process.env['AIRTABLE_API_KEY'];
+const AirtableBaseId: $TSFixMe = process.env['AIRTABLE_BASE_ID'];
+let base: $TSFixMe = null;
+if (AirtableApiKey && AirtableBaseId) {
+    base = new Airtable({ apiKey: AirtableApiKey }).base(AirtableBaseId);
+}
+
+
 export default class Service {
     /*
      * Description: Create new user entry on airtable.
@@ -169,10 +178,3 @@ export default class Service {
     }
 }
 
-import Airtable from 'airtable';
-const AirtableApiKey: $TSFixMe = process.env['AIRTABLE_API_KEY'];
-const AirtableBaseId: $TSFixMe = process.env['AIRTABLE_BASE_ID'];
-let base: $TSFixMe = null;
-if (AirtableApiKey && AirtableBaseId) {
-    base = new Airtable({ apiKey: AirtableApiKey }).base(AirtableBaseId);
-}

Mail/Index.ts

@@ -1,5 +1,9 @@
 import app from 'CommonServer/utils/StartServer';
 
-app.use(['/Mail/probe', '/probe'], require('./api/probe'));
+// API
+
+import MailAPI from './API/Mail'
+
+app.use(['/mail/email', '/email'], MailAPI);
 
 export default app;

ProbeApi/Build-temp/dist/Services/monitorService.js

@@ -0,0 +1,72 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const moment_1 = __importDefault(require("moment"));
+const database_1 = __importDefault(require("CommonServer/Utils/database"));
+const Date_1 = __importDefault(require("Common/Types/Date"));
+const monitorCollection = database_1.default.getDatabase().collection('monitors');
+exports.default = {
+    getProbeMonitors(probeId, limit) {
+        return __awaiter(this, void 0, void 0, function* () {
+            //Get monitors that have not been pinged for the last minute.
+            const date = Date_1.default.getOneMinAgo();
+            const key = `${probeId}_pingtime`;
+            const emptyQuery = {
+                deleted: false,
+                disabled: false,
+                type: {
+                    $in: ['url', 'api'],
+                },
+                [key]: { $exists: false },
+            };
+            const query = {
+                deleted: false,
+                disabled: false,
+                type: {
+                    $in: [
+                        'url',
+                        'api',
+                        'incomingHttpRequest',
+                        'kubernetes',
+                        'ip',
+                        'server-monitor',
+                    ],
+                },
+                [key]: { $lt: date },
+            };
+            let monitors = [];
+            const monitorsThatHaveNeverBeenPinged = yield monitorCollection.find(emptyQuery).limit(limit).toArray();
+            monitors = monitors.concat(monitorsThatHaveNeverBeenPinged);
+            if (monitorsThatHaveNeverBeenPinged.length < limit) {
+                const monitorsThatHaveBeenPingedBeforeOneMinute = yield monitorCollection
+                    .find(query)
+                    .sort({ [key]: 1 })
+                    .limit(limit)
+                    .toArray();
+                monitors = monitors.concat(monitorsThatHaveBeenPingedBeforeOneMinute);
+            }
+            if (monitors && monitors.length > 0) {
+                yield monitorCollection.updateMany({
+                    _id: {
+                        $in: monitors.map((monitor) => {
+                            return monitor._id;
+                        }),
+                    },
+                }, { $set: { [key]: new Date((0, moment_1.default)().format()) } });
+                return monitors;
+            }
+            return [];
+        });
+    },
+};

ProbeApi/Build-temp/dist/Services/probeService.js

@@ -0,0 +1,98 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const moment_1 = __importDefault(require("moment"));
+const mongodb_1 = require("mongodb");
+const database_1 = __importDefault(require("CommonServer/utils/database"));
+const probeCollection = database_1.default.getDatabase().collection('probes');
+const uuid_1 = require("uuid");
+const api_1 = require("../Utils/api");
+const Config_1 = require("../Config");
+const realtimeBaseUrl = `${Config_1.realtimeUrl}/realtime`;
+exports.default = {
+    create: function (data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let probeKey;
+            if (data.probeKey) {
+                probeKey = data.probeKey;
+            }
+            else {
+                probeKey = (0, uuid_1.v1)();
+            }
+            const storedProbe = yield this.findOneBy({
+                probeName: data.probeName,
+            });
+            if (storedProbe && storedProbe.probeName) {
+                const error = new Error('Probe name already exists.');
+                error.code = 400;
+                throw error;
+            }
+            else {
+                const probe = {};
+                probe.probeKey = probeKey;
+                probe.probeName = data.probeName;
+                probe.version = data.probeVersion;
+                const now = new Date((0, moment_1.default)().format());
+                probe.createdAt = now;
+                probe.lastAlive = now;
+                probe.deleted = false;
+                const result = yield probeCollection.insertOne(probe);
+                const savedProbe = yield this.findOneBy({
+                    _id: (0, mongodb_1.ObjectId)(result.insertedId),
+                });
+                return savedProbe;
+            }
+        });
+    },
+    findOneBy: function (query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!query) {
+                query = {};
+            }
+            if (!query.deleted) {
+                query.$or = [{ deleted: false }, { deleted: { $exists: false } }];
+            }
+            const probe = yield probeCollection.findOne(query);
+            return probe;
+        });
+    },
+    updateOneBy: function (query, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!query) {
+                query = {};
+            }
+            if (!query.deleted) {
+                query.$or = [{ deleted: false }, { deleted: { $exists: false } }];
+            }
+            yield probeCollection.updateOne(query, { $set: data });
+            const probe = yield this.findOneBy(query);
+            return probe;
+        });
+    },
+    updateProbeStatus: function (probeId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const now = new Date((0, moment_1.default)().format());
+            yield probeCollection.updateOne({
+                _id: (0, mongodb_1.ObjectId)(probeId),
+                $or: [{ deleted: false }, { deleted: { $exists: false } }],
+            }, { $set: { lastAlive: now } });
+            const probe = yield this.findOneBy({
+                _id: (0, mongodb_1.ObjectId)(probeId),
+            });
+            // Realtime update for probe
+            (0, api_1.post)(`${realtimeBaseUrl}/update-probe`, { data: probe }, true);
+            return probe;
+        });
+    },
+};

ProbeApi/Build-temp/dist/Utils/api.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const axios_1 = __importDefault(require("axios"));
+const config_1 = require("./config");
+const _this = {
+    getHeaders: () => {
+        return {
+            'Access-Control-Allow-Origin': '*',
+            Accept: 'application/json',
+            'Content-Type': 'application/json;charset=UTF-8',
+            clusterKey: config_1.clusterKey,
+        };
+    },
+    post: (url, data, withBaseUrl = false) => {
+        const headers = this.getHeaders();
+        return new Promise((resolve, reject) => {
+            /*
+             * Error [ERR_FR_MAX_BODY_LENGTH_EXCEEDED]: Request body larger than maxBodyLength limit
+             * https://stackoverflow.com/questions/58655532/increasing-maxcontentlength-and-maxbodylength-in-axios
+             */
+            (0, axios_1.default)({
+                method: 'POST',
+                url: withBaseUrl ? `${url}` : `${config_1.serverUrl}/${url}`,
+                headers,
+                data,
+                maxContentLength: Infinity,
+                maxBodyLength: Infinity,
+            })
+                .then((response) => {
+                resolve(response.data);
+            })
+                .then((error) => {
+                if (error && error.response && error.response.data) {
+                    error = error.response.data;
+                }
+                if (error && error.data) {
+                    error = error.data;
+                }
+                reject(error);
+            });
+        });
+    },
+};
+exports.default = _this;

ProbeApi/Build-temp/dist/api/probe.js

@@ -0,0 +1,33 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Express_1 = __importDefault(require("CommonServer/utils/Express"));
+const monitorService_1 = __importDefault(require("../Services/monitorService"));
+const router = Express_1.default.getRouter();
+const ProbeAuthorization_1 = __importDefault(require("CommonServer/middleware/ProbeAuthorization"));
+const Response_1 = require("CommonServer/utils/Response");
+const Response_2 = require("CommonServer/utils/Response");
+const PositiveNumber_1 = __importDefault(require("Common/Types/PositiveNumber"));
+router.get('/monitors', ProbeAuthorization_1.default.isAuthorizedProbe, (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const oneUptimeRequest = req;
+        const limit = new PositiveNumber_1.default(parseInt(req.query.limit || '10'));
+        const monitors = yield monitorService_1.default.getProbeMonitors(oneUptimeRequest.probe.id, limit);
+        return (0, Response_2.sendListResponse)(req, res, monitors, monitors.length);
+    }
+    catch (error) {
+        return (0, Response_1.sendErrorResponse)(req, res, error);
+    }
+}));
+exports.default = router;

ProbeApi/Build-temp/dist/index.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const StartServer_1 = __importDefault(require("CommonServer/utils/StartServer"));
+StartServer_1.default.use(['/ProbeAPI/probe', '/probe'], require('./api/probe'));
+exports.default = StartServer_1.default;

ProbeApi/Node_modules-temp/.bin/cross-env

@@ -0,0 +1 @@
+../cross-env/src/bin/cross-env.js

ProbeApi/Node_modules-temp/.bin/cross-env-shell

@@ -0,0 +1 @@
+../cross-env/src/bin/cross-env-shell.js

ProbeApi/Node_modules-temp/.bin/mime

@@ -0,0 +1 @@
+../mime/cli.js

ProbeApi/Node_modules-temp/.bin/mkdirp

@@ -0,0 +1 @@
+../mkdirp/bin/cmd.js

ProbeApi/Node_modules-temp/.bin/node-which

@@ -0,0 +1 @@
+../which/bin/node-which

ProbeApi/Node_modules-temp/.bin/resolve

@@ -0,0 +1 @@
+../resolve/bin/resolve

ProbeApi/Node_modules-temp/.bin/rimraf

@@ -0,0 +1 @@
+../rimraf/bin.js

ProbeApi/Node_modules-temp/.bin/tree-kill

@@ -0,0 +1 @@
+../tree-kill/cli.js

ProbeApi/Node_modules-temp/.bin/ts-node

@@ -0,0 +1 @@
+../ts-node/dist/bin.js

ProbeApi/Node_modules-temp/.bin/ts-node-dev

@@ -0,0 +1 @@
+../ts-node-dev/lib/bin.js

ProbeApi/Node_modules-temp/.bin/ts-node-script

@@ -0,0 +1 @@
+../ts-node/dist/bin-script.js

ProbeApi/Node_modules-temp/.bin/ts-node-transpile-only

@@ -0,0 +1 @@
+../ts-node/dist/bin-transpile.js

ProbeApi/Node_modules-temp/.bin/ts-script

@@ -0,0 +1 @@
+../ts-node/dist/bin-script-deprecated.js

ProbeApi/Node_modules-temp/.bin/tsc

@@ -0,0 +1 @@
+../typescript/bin/tsc

ProbeApi/Node_modules-temp/.bin/tsnd

@@ -0,0 +1 @@
+../ts-node-dev/lib/bin.js

ProbeApi/Node_modules-temp/.bin/tsserver

@@ -0,0 +1 @@
+../typescript/bin/tsserver

ProbeApi/Node_modules-temp/.bin/uuid

@@ -0,0 +1 @@
+../uuid/dist/bin/uuid

ProbeApi/Node_modules-temp/@colors/colors/LICENSE

@@ -0,0 +1,26 @@
+MIT License
+
+Original Library
+  - Copyright (c) Marak Squires
+
+Additional Functionality
+ - Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
+ - Copyright (c) DABH (https://github.com/DABH)
+
+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.

ProbeApi/Node_modules-temp/@colors/colors/README.md

@@ -0,0 +1,219 @@
+# @colors/colors ("colors.js")
+[![Build Status](https://github.com/DABH/colors.js/actions/workflows/ci.yml/badge.svg)](https://github.com/DABH/colors.js/actions/workflows/ci.yml)
+[![version](https://img.shields.io/npm/v/@colors/colors.svg)](https://www.npmjs.org/package/@colors/colors)
+
+Please check out the [roadmap](ROADMAP.md) for upcoming features and releases.  Please open Issues to provide feedback.
+
+## get color and style in your node.js console
+
+![Demo](https://raw.githubusercontent.com/DABH/colors.js/master/screenshots/colors.png)
+
+## Installation
+
+    npm install @colors/colors
+
+## colors and styles!
+
+### text colors
+
+  - black
+  - red
+  - green
+  - yellow
+  - blue
+  - magenta
+  - cyan
+  - white
+  - gray
+  - grey
+
+### bright text colors
+
+  - brightRed
+  - brightGreen
+  - brightYellow
+  - brightBlue
+  - brightMagenta
+  - brightCyan
+  - brightWhite
+
+### background colors
+
+  - bgBlack
+  - bgRed
+  - bgGreen
+  - bgYellow
+  - bgBlue
+  - bgMagenta
+  - bgCyan
+  - bgWhite
+  - bgGray
+  - bgGrey
+
+### bright background colors
+
+  - bgBrightRed
+  - bgBrightGreen
+  - bgBrightYellow
+  - bgBrightBlue
+  - bgBrightMagenta
+  - bgBrightCyan
+  - bgBrightWhite
+
+### styles
+
+  - reset
+  - bold
+  - dim
+  - italic
+  - underline
+  - inverse
+  - hidden
+  - strikethrough
+
+### extras
+
+  - rainbow
+  - zebra
+  - america
+  - trap
+  - random
+
+
+## Usage
+
+By popular demand, `@colors/colors` now ships with two types of usages!
+
+The super nifty way
+
+```js
+var colors = require('@colors/colors');
+
+console.log('hello'.green); // outputs green text
+console.log('i like cake and pies'.underline.red); // outputs red underlined text
+console.log('inverse the color'.inverse); // inverses the color
+console.log('OMG Rainbows!'.rainbow); // rainbow
+console.log('Run the trap'.trap); // Drops the bass
+
+```
+
+or a slightly less nifty way which doesn't extend `String.prototype`
+
+```js
+var colors = require('@colors/colors/safe');
+
+console.log(colors.green('hello')); // outputs green text
+console.log(colors.red.underline('i like cake and pies')); // outputs red underlined text
+console.log(colors.inverse('inverse the color')); // inverses the color
+console.log(colors.rainbow('OMG Rainbows!')); // rainbow
+console.log(colors.trap('Run the trap')); // Drops the bass
+
+```
+
+I prefer the first way. Some people seem to be afraid of extending `String.prototype` and prefer the second way. 
+
+If you are writing good code you will never have an issue with the first approach. If you really don't want to touch `String.prototype`, the second usage will not touch `String` native object.
+
+## Enabling/Disabling Colors
+
+The package will auto-detect whether your terminal can use colors and enable/disable accordingly. When colors are disabled, the color functions do nothing. You can override this with a command-line flag:
+
+```bash
+node myapp.js --no-color
+node myapp.js --color=false
+
+node myapp.js --color
+node myapp.js --color=true
+node myapp.js --color=always
+
+FORCE_COLOR=1 node myapp.js
+```
+
+Or in code:
+
+```javascript
+var colors = require('@colors/colors');
+colors.enable();
+colors.disable();
+```
+
+## Console.log [string substitution](http://nodejs.org/docs/latest/api/console.html#console_console_log_data)
+
+```js
+var name = 'Beowulf';
+console.log(colors.green('Hello %s'), name);
+// outputs -> 'Hello Beowulf'
+```
+
+## Custom themes
+
+### Using standard API
+
+```js
+
+var colors = require('@colors/colors');
+
+colors.setTheme({
+  silly: 'rainbow',
+  input: 'grey',
+  verbose: 'cyan',
+  prompt: 'grey',
+  info: 'green',
+  data: 'grey',
+  help: 'cyan',
+  warn: 'yellow',
+  debug: 'blue',
+  error: 'red'
+});
+
+// outputs red text
+console.log("this is an error".error);
+
+// outputs yellow text
+console.log("this is a warning".warn);
+```
+
+### Using string safe API
+
+```js
+var colors = require('@colors/colors/safe');
+
+// set single property
+var error = colors.red;
+error('this is red');
+
+// set theme
+colors.setTheme({
+  silly: 'rainbow',
+  input: 'grey',
+  verbose: 'cyan',
+  prompt: 'grey',
+  info: 'green',
+  data: 'grey',
+  help: 'cyan',
+  warn: 'yellow',
+  debug: 'blue',
+  error: 'red'
+});
+
+// outputs red text
+console.log(colors.error("this is an error"));
+
+// outputs yellow text
+console.log(colors.warn("this is a warning"));
+
+```
+
+### Combining Colors
+
+```javascript
+var colors = require('@colors/colors');
+
+colors.setTheme({
+  custom: ['red', 'underline']
+});
+
+console.log('test'.custom);
+```
+
+*Protip: There is a secret undocumented style in `colors`. If you find the style you can summon him.*

ProbeApi/Node_modules-temp/@colors/colors/examples/normal-usage.js

@@ -0,0 +1,83 @@
+var colors = require('../lib/index');
+
+console.log('First some yellow text'.yellow);
+
+console.log('Underline that text'.yellow.underline);
+
+console.log('Make it bold and red'.red.bold);
+
+console.log(('Double Raindows All Day Long').rainbow);
+
+console.log('Drop the bass'.trap);
+
+console.log('DROP THE RAINBOW BASS'.trap.rainbow);
+
+// styles not widely supported
+console.log('Chains are also cool.'.bold.italic.underline.red);
+
+// styles not widely supported
+console.log('So '.green + 'are'.underline + ' ' + 'inverse'.inverse
+  + ' styles! '.yellow.bold);
+console.log('Zebras are so fun!'.zebra);
+
+//
+// Remark: .strikethrough may not work with Mac OS Terminal App
+//
+console.log('This is ' + 'not'.strikethrough + ' fun.');
+
+console.log('Background color attack!'.black.bgWhite);
+console.log('Use random styles on everything!'.random);
+console.log('America, Heck Yeah!'.america);
+
+// eslint-disable-next-line max-len
+console.log('Blindingly '.brightCyan + 'bright? '.brightRed + 'Why '.brightYellow + 'not?!'.brightGreen);
+
+console.log('Setting themes is useful');
+
+//
+// Custom themes
+//
+console.log('Generic logging theme as JSON'.green.bold.underline);
+// Load theme with JSON literal
+colors.setTheme({
+  silly: 'rainbow',
+  input: 'grey',
+  verbose: 'cyan',
+  prompt: 'grey',
+  info: 'green',
+  data: 'grey',
+  help: 'cyan',
+  warn: 'yellow',
+  debug: 'blue',
+  error: 'red',
+});
+
+// outputs red text
+console.log('this is an error'.error);
+
+// outputs yellow text
+console.log('this is a warning'.warn);
+
+// outputs grey text
+console.log('this is an input'.input);
+
+console.log('Generic logging theme as file'.green.bold.underline);
+
+// Load a theme from file
+try {
+  colors.setTheme(require(__dirname + '/../themes/generic-logging.js'));
+} catch (err) {
+  console.log(err);
+}
+
+// outputs red text
+console.log('this is an error'.error);
+
+// outputs yellow text
+console.log('this is a warning'.warn);
+
+// outputs grey text
+console.log('this is an input'.input);
+
+// console.log("Don't summon".zalgo)
+

ProbeApi/Node_modules-temp/@colors/colors/examples/safe-string.js

@@ -0,0 +1,80 @@
+var colors = require('../safe');
+
+console.log(colors.yellow('First some yellow text'));
+
+console.log(colors.yellow.underline('Underline that text'));
+
+console.log(colors.red.bold('Make it bold and red'));
+
+console.log(colors.rainbow('Double Raindows All Day Long'));
+
+console.log(colors.trap('Drop the bass'));
+
+console.log(colors.rainbow(colors.trap('DROP THE RAINBOW BASS')));
+
+// styles not widely supported
+console.log(colors.bold.italic.underline.red('Chains are also cool.'));
+
+// styles not widely supported
+console.log(colors.green('So ') + colors.underline('are') + ' '
+  + colors.inverse('inverse') + colors.yellow.bold(' styles! '));
+
+console.log(colors.zebra('Zebras are so fun!'));
+
+console.log('This is ' + colors.strikethrough('not') + ' fun.');
+
+
+console.log(colors.black.bgWhite('Background color attack!'));
+console.log(colors.random('Use random styles on everything!'));
+console.log(colors.america('America, Heck Yeah!'));
+
+// eslint-disable-next-line max-len
+console.log(colors.brightCyan('Blindingly ') + colors.brightRed('bright? ') + colors.brightYellow('Why ') + colors.brightGreen('not?!'));
+
+console.log('Setting themes is useful');
+
+//
+// Custom themes
+//
+// console.log('Generic logging theme as JSON'.green.bold.underline);
+// Load theme with JSON literal
+colors.setTheme({
+  silly: 'rainbow',
+  input: 'blue',
+  verbose: 'cyan',
+  prompt: 'grey',
+  info: 'green',
+  data: 'grey',
+  help: 'cyan',
+  warn: 'yellow',
+  debug: 'blue',
+  error: 'red',
+});
+
+// outputs red text
+console.log(colors.error('this is an error'));
+
+// outputs yellow text
+console.log(colors.warn('this is a warning'));
+
+// outputs blue text
+console.log(colors.input('this is an input'));
+
+
+// console.log('Generic logging theme as file'.green.bold.underline);
+
+// Load a theme from file
+colors.setTheme(require(__dirname + '/../themes/generic-logging.js'));
+
+// outputs red text
+console.log(colors.error('this is an error'));
+
+// outputs yellow text
+console.log(colors.warn('this is a warning'));
+
+// outputs grey text
+console.log(colors.input('this is an input'));
+
+// console.log(colors.zalgo("Don't summon him"))
+
+

ProbeApi/Node_modules-temp/@colors/colors/index.d.ts

@@ -0,0 +1,136 @@
+// Type definitions for @colors/colors 1.4+
+// Project: https://github.com/Marak/colors.js
+// Definitions by: Bart van der Schoor <https://github.com/Bartvds>, Staffan Eketorp <https://github.com/staeke>
+// Definitions: https://github.com/DABH/colors.js
+
+export interface Color {
+    (text: string): string;
+
+    strip: Color;
+    stripColors: Color;
+
+    black: Color;
+    red: Color;
+    green: Color;
+    yellow: Color;
+    blue: Color;
+    magenta: Color;
+    cyan: Color;
+    white: Color;
+    gray: Color;
+    grey: Color;
+
+    bgBlack: Color;
+    bgRed: Color;
+    bgGreen: Color;
+    bgYellow: Color;
+    bgBlue: Color;
+    bgMagenta: Color;
+    bgCyan: Color;
+    bgWhite: Color;
+
+    reset: Color;
+    bold: Color;
+    dim: Color;
+    italic: Color;
+    underline: Color;
+    inverse: Color;
+    hidden: Color;
+    strikethrough: Color;
+
+    rainbow: Color;
+    zebra: Color;
+    america: Color;
+    trap: Color;
+    random: Color;
+    zalgo: Color;
+}
+
+export function enable(): void;
+export function disable(): void;
+export function setTheme(theme: any): void;
+
+export let enabled: boolean;
+
+export const strip: Color;
+export const stripColors: Color;
+
+export const black: Color;
+export const red: Color;
+export const green: Color;
+export const yellow: Color;
+export const blue: Color;
+export const magenta: Color;
+export const cyan: Color;
+export const white: Color;
+export const gray: Color;
+export const grey: Color;
+
+export const bgBlack: Color;
+export const bgRed: Color;
+export const bgGreen: Color;
+export const bgYellow: Color;
+export const bgBlue: Color;
+export const bgMagenta: Color;
+export const bgCyan: Color;
+export const bgWhite: Color;
+
+export const reset: Color;
+export const bold: Color;
+export const dim: Color;
+export const italic: Color;
+export const underline: Color;
+export const inverse: Color;
+export const hidden: Color;
+export const strikethrough: Color;
+
+export const rainbow: Color;
+export const zebra: Color;
+export const america: Color;
+export const trap: Color;
+export const random: Color;
+export const zalgo: Color;
+
+declare global {
+    interface String {
+        strip: string;
+        stripColors: string;
+
+        black: string;
+        red: string;
+        green: string;
+        yellow: string;
+        blue: string;
+        magenta: string;
+        cyan: string;
+        white: string;
+        gray: string;
+        grey: string;
+
+        bgBlack: string;
+        bgRed: string;
+        bgGreen: string;
+        bgYellow: string;
+        bgBlue: string;
+        bgMagenta: string;
+        bgCyan: string;
+        bgWhite: string;
+
+        reset: string;
+        // @ts-ignore
+        bold: string;
+        dim: string;
+        italic: string;
+        underline: string;
+        inverse: string;
+        hidden: string;
+        strikethrough: string;
+
+        rainbow: string;
+        zebra: string;
+        america: string;
+        trap: string;
+        random: string;
+        zalgo: string;
+    }
+}

ProbeApi/Node_modules-temp/@colors/colors/lib/colors.js

@@ -0,0 +1,211 @@
+/*
+
+The MIT License (MIT)
+
+Original Library
+  - Copyright (c) Marak Squires
+
+Additional functionality
+ - Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
+
+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.
+
+*/
+
+var colors = {};
+module['exports'] = colors;
+
+colors.themes = {};
+
+var util = require('util');
+var ansiStyles = colors.styles = require('./styles');
+var defineProps = Object.defineProperties;
+var newLineRegex = new RegExp(/[\r\n]+/g);
+
+colors.supportsColor = require('./system/supports-colors').supportsColor;
+
+if (typeof colors.enabled === 'undefined') {
+  colors.enabled = colors.supportsColor() !== false;
+}
+
+colors.enable = function() {
+  colors.enabled = true;
+};
+
+colors.disable = function() {
+  colors.enabled = false;
+};
+
+colors.stripColors = colors.strip = function(str) {
+  return ('' + str).replace(/\x1B\[\d+m/g, '');
+};
+
+// eslint-disable-next-line no-unused-vars
+var stylize = colors.stylize = function stylize(str, style) {
+  if (!colors.enabled) {
+    return str+'';
+  }
+
+  var styleMap = ansiStyles[style];
+
+  // Stylize should work for non-ANSI styles, too
+  if (!styleMap && style in colors) {
+    // Style maps like trap operate as functions on strings;
+    // they don't have properties like open or close.
+    return colors[style](str);
+  }
+
+  return styleMap.open + str + styleMap.close;
+};
+
+var matchOperatorsRe = /[|\\{}()[\]^$+*?.]/g;
+var escapeStringRegexp = function(str) {
+  if (typeof str !== 'string') {
+    throw new TypeError('Expected a string');
+  }
+  return str.replace(matchOperatorsRe, '\\$&');
+};
+
+function build(_styles) {
+  var builder = function builder() {
+    return applyStyle.apply(builder, arguments);
+  };
+  builder._styles = _styles;
+  // __proto__ is used because we must return a function, but there is
+  // no way to create a function with a different prototype.
+  builder.__proto__ = proto;
+  return builder;
+}
+
+var styles = (function() {
+  var ret = {};
+  ansiStyles.grey = ansiStyles.gray;
+  Object.keys(ansiStyles).forEach(function(key) {
+    ansiStyles[key].closeRe =
+      new RegExp(escapeStringRegexp(ansiStyles[key].close), 'g');
+    ret[key] = {
+      get: function() {
+        return build(this._styles.concat(key));
+      },
+    };
+  });
+  return ret;
+})();
+
+var proto = defineProps(function colors() {}, styles);
+
+function applyStyle() {
+  var args = Array.prototype.slice.call(arguments);
+
+  var str = args.map(function(arg) {
+    // Use weak equality check so we can colorize null/undefined in safe mode
+    if (arg != null && arg.constructor === String) {
+      return arg;
+    } else {
+      return util.inspect(arg);
+    }
+  }).join(' ');
+
+  if (!colors.enabled || !str) {
+    return str;
+  }
+
+  var newLinesPresent = str.indexOf('\n') != -1;
+
+  var nestedStyles = this._styles;
+
+  var i = nestedStyles.length;
+  while (i--) {
+    var code = ansiStyles[nestedStyles[i]];
+    str = code.open + str.replace(code.closeRe, code.open) + code.close;
+    if (newLinesPresent) {
+      str = str.replace(newLineRegex, function(match) {
+        return code.close + match + code.open;
+      });
+    }
+  }
+
+  return str;
+}
+
+colors.setTheme = function(theme) {
+  if (typeof theme === 'string') {
+    console.log('colors.setTheme now only accepts an object, not a string.  ' +
+      'If you are trying to set a theme from a file, it is now your (the ' +
+      'caller\'s) responsibility to require the file.  The old syntax ' +
+      'looked like colors.setTheme(__dirname + ' +
+      '\'/../themes/generic-logging.js\'); The new syntax looks like '+
+      'colors.setTheme(require(__dirname + ' +
+      '\'/../themes/generic-logging.js\'));');
+    return;
+  }
+  for (var style in theme) {
+    (function(style) {
+      colors[style] = function(str) {
+        if (typeof theme[style] === 'object') {
+          var out = str;
+          for (var i in theme[style]) {
+            out = colors[theme[style][i]](out);
+          }
+          return out;
+        }
+        return colors[theme[style]](str);
+      };
+    })(style);
+  }
+};
+
+function init() {
+  var ret = {};
+  Object.keys(styles).forEach(function(name) {
+    ret[name] = {
+      get: function() {
+        return build([name]);
+      },
+    };
+  });
+  return ret;
+}
+
+var sequencer = function sequencer(map, str) {
+  var exploded = str.split('');
+  exploded = exploded.map(map);
+  return exploded.join('');
+};
+
+// custom formatter methods
+colors.trap = require('./custom/trap');
+colors.zalgo = require('./custom/zalgo');
+
+// maps
+colors.maps = {};
+colors.maps.america = require('./maps/america')(colors);
+colors.maps.zebra = require('./maps/zebra')(colors);
+colors.maps.rainbow = require('./maps/rainbow')(colors);
+colors.maps.random = require('./maps/random')(colors);
+
+for (var map in colors.maps) {
+  (function(map) {
+    colors[map] = function(str) {
+      return sequencer(colors.maps[map], str);
+    };
+  })(map);
+}
+
+defineProps(colors, init());

ProbeApi/Node_modules-temp/@colors/colors/lib/custom/trap.js

@@ -0,0 +1,46 @@
+module['exports'] = function runTheTrap(text, options) {
+  var result = '';
+  text = text || 'Run the trap, drop the bass';
+  text = text.split('');
+  var trap = {
+    a: ['\u0040', '\u0104', '\u023a', '\u0245', '\u0394', '\u039b', '\u0414'],
+    b: ['\u00df', '\u0181', '\u0243', '\u026e', '\u03b2', '\u0e3f'],
+    c: ['\u00a9', '\u023b', '\u03fe'],
+    d: ['\u00d0', '\u018a', '\u0500', '\u0501', '\u0502', '\u0503'],
+    e: ['\u00cb', '\u0115', '\u018e', '\u0258', '\u03a3', '\u03be', '\u04bc',
+      '\u0a6c'],
+    f: ['\u04fa'],
+    g: ['\u0262'],
+    h: ['\u0126', '\u0195', '\u04a2', '\u04ba', '\u04c7', '\u050a'],
+    i: ['\u0f0f'],
+    j: ['\u0134'],
+    k: ['\u0138', '\u04a0', '\u04c3', '\u051e'],
+    l: ['\u0139'],
+    m: ['\u028d', '\u04cd', '\u04ce', '\u0520', '\u0521', '\u0d69'],
+    n: ['\u00d1', '\u014b', '\u019d', '\u0376', '\u03a0', '\u048a'],
+    o: ['\u00d8', '\u00f5', '\u00f8', '\u01fe', '\u0298', '\u047a', '\u05dd',
+      '\u06dd', '\u0e4f'],
+    p: ['\u01f7', '\u048e'],
+    q: ['\u09cd'],
+    r: ['\u00ae', '\u01a6', '\u0210', '\u024c', '\u0280', '\u042f'],
+    s: ['\u00a7', '\u03de', '\u03df', '\u03e8'],
+    t: ['\u0141', '\u0166', '\u0373'],
+    u: ['\u01b1', '\u054d'],
+    v: ['\u05d8'],
+    w: ['\u0428', '\u0460', '\u047c', '\u0d70'],
+    x: ['\u04b2', '\u04fe', '\u04fc', '\u04fd'],
+    y: ['\u00a5', '\u04b0', '\u04cb'],
+    z: ['\u01b5', '\u0240'],
+  };
+  text.forEach(function(c) {
+    c = c.toLowerCase();
+    var chars = trap[c] || [' '];
+    var rand = Math.floor(Math.random() * chars.length);
+    if (typeof trap[c] !== 'undefined') {
+      result += trap[c][rand];
+    } else {
+      result += c;
+    }
+  });
+  return result;
+};

ProbeApi/Node_modules-temp/@colors/colors/lib/custom/zalgo.js

@@ -0,0 +1,110 @@
+// please no
+module['exports'] = function zalgo(text, options) {
+  text = text || '   he is here   ';
+  var soul = {
+    'up': [
+      '̍', '̎', '̄', '̅',
+      '̿', '̑', '̆', '̐',
+      '͒', '͗', '͑', '̇',
+      '̈', '̊', '͂', '̓',
+      '̈', '͊', '͋', '͌',
+      '̃', '̂', '̌', '͐',
+      '̀', '́', '̋', '̏',
+      '̒', '̓', '̔', '̽',
+      '̉', 'ͣ', 'ͤ', 'ͥ',
+      'ͦ', 'ͧ', 'ͨ', 'ͩ',
+      'ͪ', 'ͫ', 'ͬ', 'ͭ',
+      'ͮ', 'ͯ', '̾', '͛',
+      '͆', '̚',
+    ],
+    'down': [
+      '̖', '̗', '̘', '̙',
+      '̜', '̝', '̞', '̟',
+      '̠', '̤', '̥', '̦',
+      '̩', '̪', '̫', '̬',
+      '̭', '̮', '̯', '̰',
+      '̱', '̲', '̳', '̹',
+      '̺', '̻', '̼', 'ͅ',
+      '͇', '͈', '͉', '͍',
+      '͎', '͓', '͔', '͕',
+      '͖', '͙', '͚', '̣',
+    ],
+    'mid': [
+      '̕', '̛', '̀', '́',
+      '͘', '̡', '̢', '̧',
+      '̨', '̴', '̵', '̶',
+      '͜', '͝', '͞',
+      '͟', '͠', '͢', '̸',
+      '̷', '͡', ' ҉',
+    ],
+  };
+  var all = [].concat(soul.up, soul.down, soul.mid);
+
+  function randomNumber(range) {
+    var r = Math.floor(Math.random() * range);
+    return r;
+  }
+
+  function isChar(character) {
+    var bool = false;
+    all.filter(function(i) {
+      bool = (i === character);
+    });
+    return bool;
+  }
+
+
+  function heComes(text, options) {
+    var result = '';
+    var counts;
+    var l;
+    options = options || {};
+    options['up'] =
+      typeof options['up'] !== 'undefined' ? options['up'] : true;
+    options['mid'] =
+      typeof options['mid'] !== 'undefined' ? options['mid'] : true;
+    options['down'] =
+      typeof options['down'] !== 'undefined' ? options['down'] : true;
+    options['size'] =
+      typeof options['size'] !== 'undefined' ? options['size'] : 'maxi';
+    text = text.split('');
+    for (l in text) {
+      if (isChar(l)) {
+        continue;
+      }
+      result = result + text[l];
+      counts = {'up': 0, 'down': 0, 'mid': 0};
+      switch (options.size) {
+        case 'mini':
+          counts.up = randomNumber(8);
+          counts.mid = randomNumber(2);
+          counts.down = randomNumber(8);
+          break;
+        case 'maxi':
+          counts.up = randomNumber(16) + 3;
+          counts.mid = randomNumber(4) + 1;
+          counts.down = randomNumber(64) + 3;
+          break;
+        default:
+          counts.up = randomNumber(8) + 1;
+          counts.mid = randomNumber(6) / 2;
+          counts.down = randomNumber(8) + 1;
+          break;
+      }
+
+      var arr = ['up', 'mid', 'down'];
+      for (var d in arr) {
+        var index = arr[d];
+        for (var i = 0; i <= counts[index]; i++) {
+          if (options[index]) {
+            result = result + soul[index][randomNumber(soul[index].length)];
+          }
+        }
+      }
+    }
+    return result;
+  }
+  // don't summon him
+  return heComes(text, options);
+};
+

ProbeApi/Node_modules-temp/@colors/colors/lib/extendStringPrototype.js

@@ -0,0 +1,110 @@
+var colors = require('./colors');
+
+module['exports'] = function() {
+  //
+  // Extends prototype of native string object to allow for "foo".red syntax
+  //
+  var addProperty = function(color, func) {
+    String.prototype.__defineGetter__(color, func);
+  };
+
+  addProperty('strip', function() {
+    return colors.strip(this);
+  });
+
+  addProperty('stripColors', function() {
+    return colors.strip(this);
+  });
+
+  addProperty('trap', function() {
+    return colors.trap(this);
+  });
+
+  addProperty('zalgo', function() {
+    return colors.zalgo(this);
+  });
+
+  addProperty('zebra', function() {
+    return colors.zebra(this);
+  });
+
+  addProperty('rainbow', function() {
+    return colors.rainbow(this);
+  });
+
+  addProperty('random', function() {
+    return colors.random(this);
+  });
+
+  addProperty('america', function() {
+    return colors.america(this);
+  });
+
+  //
+  // Iterate through all default styles and colors
+  //
+  var x = Object.keys(colors.styles);
+  x.forEach(function(style) {
+    addProperty(style, function() {
+      return colors.stylize(this, style);
+    });
+  });
+
+  function applyTheme(theme) {
+    //
+    // Remark: This is a list of methods that exist
+    // on String that you should not overwrite.
+    //
+    var stringPrototypeBlacklist = [
+      '__defineGetter__', '__defineSetter__', '__lookupGetter__',
+      '__lookupSetter__', 'charAt', 'constructor', 'hasOwnProperty',
+      'isPrototypeOf', 'propertyIsEnumerable', 'toLocaleString', 'toString',
+      'valueOf', 'charCodeAt', 'indexOf', 'lastIndexOf', 'length',
+      'localeCompare', 'match', 'repeat', 'replace', 'search', 'slice',
+      'split', 'substring', 'toLocaleLowerCase', 'toLocaleUpperCase',
+      'toLowerCase', 'toUpperCase', 'trim', 'trimLeft', 'trimRight',
+    ];
+
+    Object.keys(theme).forEach(function(prop) {
+      if (stringPrototypeBlacklist.indexOf(prop) !== -1) {
+        console.log('warn: '.red + ('String.prototype' + prop).magenta +
+          ' is probably something you don\'t want to override.  ' +
+          'Ignoring style name');
+      } else {
+        if (typeof(theme[prop]) === 'string') {
+          colors[prop] = colors[theme[prop]];
+          addProperty(prop, function() {
+            return colors[prop](this);
+          });
+        } else {
+          var themePropApplicator = function(str) {
+            var ret = str || this;
+            for (var t = 0; t < theme[prop].length; t++) {
+              ret = colors[theme[prop][t]](ret);
+            }
+            return ret;
+          };
+          addProperty(prop, themePropApplicator);
+          colors[prop] = function(str) {
+            return themePropApplicator(str);
+          };
+        }
+      }
+    });
+  }
+
+  colors.setTheme = function(theme) {
+    if (typeof theme === 'string') {
+      console.log('colors.setTheme now only accepts an object, not a string. ' +
+        'If you are trying to set a theme from a file, it is now your (the ' +
+        'caller\'s) responsibility to require the file.  The old syntax ' +
+        'looked like colors.setTheme(__dirname + ' +
+        '\'/../themes/generic-logging.js\'); The new syntax looks like '+
+        'colors.setTheme(require(__dirname + ' +
+        '\'/../themes/generic-logging.js\'));');
+      return;
+    } else {
+      applyTheme(theme);
+    }
+  };
+};

ProbeApi/Node_modules-temp/@colors/colors/lib/index.js

@@ -0,0 +1,13 @@
+var colors = require('./colors');
+module['exports'] = colors;
+
+// Remark: By default, colors will add style properties to String.prototype.
+//
+// If you don't wish to extend String.prototype, you can do this instead and
+// native String will not be touched:
+//
+//   var colors = require('colors/safe);
+//   colors.red("foo")
+//
+//
+require('./extendStringPrototype')();

ProbeApi/Node_modules-temp/@colors/colors/lib/maps/america.js

@@ -0,0 +1,10 @@
+module['exports'] = function(colors) {
+  return function(letter, i, exploded) {
+    if (letter === ' ') return letter;
+    switch (i%3) {
+      case 0: return colors.red(letter);
+      case 1: return colors.white(letter);
+      case 2: return colors.blue(letter);
+    }
+  };
+};

ProbeApi/Node_modules-temp/@colors/colors/lib/maps/rainbow.js

@@ -0,0 +1,12 @@
+module['exports'] = function(colors) {
+  // RoY G BiV
+  var rainbowColors = ['red', 'yellow', 'green', 'blue', 'magenta'];
+  return function(letter, i, exploded) {
+    if (letter === ' ') {
+      return letter;
+    } else {
+      return colors[rainbowColors[i++ % rainbowColors.length]](letter);
+    }
+  };
+};
+

ProbeApi/Node_modules-temp/@colors/colors/lib/maps/random.js

@@ -0,0 +1,11 @@
+module['exports'] = function(colors) {
+  var available = ['underline', 'inverse', 'grey', 'yellow', 'red', 'green',
+    'blue', 'white', 'cyan', 'magenta', 'brightYellow', 'brightRed',
+    'brightGreen', 'brightBlue', 'brightWhite', 'brightCyan', 'brightMagenta'];
+  return function(letter, i, exploded) {
+    return letter === ' ' ? letter :
+      colors[
+          available[Math.round(Math.random() * (available.length - 2))]
+      ](letter);
+  };
+};

ProbeApi/Node_modules-temp/@colors/colors/lib/maps/zebra.js

@@ -0,0 +1,5 @@
+module['exports'] = function(colors) {
+  return function(letter, i, exploded) {
+    return i % 2 === 0 ? letter : colors.inverse(letter);
+  };
+};

ProbeApi/Node_modules-temp/@colors/colors/lib/styles.js

@@ -0,0 +1,95 @@
+/*
+The MIT License (MIT)
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
+
+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.
+
+*/
+
+var styles = {};
+module['exports'] = styles;
+
+var codes = {
+  reset: [0, 0],
+
+  bold: [1, 22],
+  dim: [2, 22],
+  italic: [3, 23],
+  underline: [4, 24],
+  inverse: [7, 27],
+  hidden: [8, 28],
+  strikethrough: [9, 29],
+
+  black: [30, 39],
+  red: [31, 39],
+  green: [32, 39],
+  yellow: [33, 39],
+  blue: [34, 39],
+  magenta: [35, 39],
+  cyan: [36, 39],
+  white: [37, 39],
+  gray: [90, 39],
+  grey: [90, 39],
+
+  brightRed: [91, 39],
+  brightGreen: [92, 39],
+  brightYellow: [93, 39],
+  brightBlue: [94, 39],
+  brightMagenta: [95, 39],
+  brightCyan: [96, 39],
+  brightWhite: [97, 39],
+
+  bgBlack: [40, 49],
+  bgRed: [41, 49],
+  bgGreen: [42, 49],
+  bgYellow: [43, 49],
+  bgBlue: [44, 49],
+  bgMagenta: [45, 49],
+  bgCyan: [46, 49],
+  bgWhite: [47, 49],
+  bgGray: [100, 49],
+  bgGrey: [100, 49],
+
+  bgBrightRed: [101, 49],
+  bgBrightGreen: [102, 49],
+  bgBrightYellow: [103, 49],
+  bgBrightBlue: [104, 49],
+  bgBrightMagenta: [105, 49],
+  bgBrightCyan: [106, 49],
+  bgBrightWhite: [107, 49],
+
+  // legacy styles for colors pre v1.0.0
+  blackBG: [40, 49],
+  redBG: [41, 49],
+  greenBG: [42, 49],
+  yellowBG: [43, 49],
+  blueBG: [44, 49],
+  magentaBG: [45, 49],
+  cyanBG: [46, 49],
+  whiteBG: [47, 49],
+
+};
+
+Object.keys(codes).forEach(function(key) {
+  var val = codes[key];
+  var style = styles[key] = [];
+  style.open = '\u001b[' + val[0] + 'm';
+  style.close = '\u001b[' + val[1] + 'm';
+});

ProbeApi/Node_modules-temp/@colors/colors/lib/system/has-flag.js

@@ -0,0 +1,35 @@
+/*
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
+
+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.
+*/
+
+'use strict';
+
+module.exports = function(flag, argv) {
+  argv = argv || process.argv;
+
+  var terminatorPos = argv.indexOf('--');
+  var prefix = /^-{1,2}/.test(flag) ? '' : '--';
+  var pos = argv.indexOf(prefix + flag);
+
+  return pos !== -1 && (terminatorPos === -1 ? true : pos < terminatorPos);
+};

ProbeApi/Node_modules-temp/@colors/colors/lib/system/supports-colors.js

@@ -0,0 +1,151 @@
+/*
+The MIT License (MIT)
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
+
+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.
+
+*/
+
+'use strict';
+
+var os = require('os');
+var hasFlag = require('./has-flag.js');
+
+var env = process.env;
+
+var forceColor = void 0;
+if (hasFlag('no-color') || hasFlag('no-colors') || hasFlag('color=false')) {
+  forceColor = false;
+} else if (hasFlag('color') || hasFlag('colors') || hasFlag('color=true')
+           || hasFlag('color=always')) {
+  forceColor = true;
+}
+if ('FORCE_COLOR' in env) {
+  forceColor = env.FORCE_COLOR.length === 0
+    || parseInt(env.FORCE_COLOR, 10) !== 0;
+}
+
+function translateLevel(level) {
+  if (level === 0) {
+    return false;
+  }
+
+  return {
+    level: level,
+    hasBasic: true,
+    has256: level >= 2,
+    has16m: level >= 3,
+  };
+}
+
+function supportsColor(stream) {
+  if (forceColor === false) {
+    return 0;
+  }
+
+  if (hasFlag('color=16m') || hasFlag('color=full')
+      || hasFlag('color=truecolor')) {
+    return 3;
+  }
+
+  if (hasFlag('color=256')) {
+    return 2;
+  }
+
+  if (stream && !stream.isTTY && forceColor !== true) {
+    return 0;
+  }
+
+  var min = forceColor ? 1 : 0;
+
+  if (process.platform === 'win32') {
+    // Node.js 7.5.0 is the first version of Node.js to include a patch to
+    // libuv that enables 256 color output on Windows. Anything earlier and it
+    // won't work. However, here we target Node.js 8 at minimum as it is an LTS
+    // release, and Node.js 7 is not. Windows 10 build 10586 is the first
+    // Windows release that supports 256 colors. Windows 10 build 14931 is the
+    // first release that supports 16m/TrueColor.
+    var osRelease = os.release().split('.');
+    if (Number(process.versions.node.split('.')[0]) >= 8
+        && Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+      return Number(osRelease[2]) >= 14931 ? 3 : 2;
+    }
+
+    return 1;
+  }
+
+  if ('CI' in env) {
+    if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI'].some(function(sign) {
+      return sign in env;
+    }) || env.CI_NAME === 'codeship') {
+      return 1;
+    }
+
+    return min;
+  }
+
+  if ('TEAMCITY_VERSION' in env) {
+    return (/^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0
+    );
+  }
+
+  if ('TERM_PROGRAM' in env) {
+    var version = parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
+
+    switch (env.TERM_PROGRAM) {
+      case 'iTerm.app':
+        return version >= 3 ? 3 : 2;
+      case 'Hyper':
+        return 3;
+      case 'Apple_Terminal':
+        return 2;
+      // No default
+    }
+  }
+
+  if (/-256(color)?$/i.test(env.TERM)) {
+    return 2;
+  }
+
+  if (/^screen|^xterm|^vt100|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+    return 1;
+  }
+
+  if ('COLORTERM' in env) {
+    return 1;
+  }
+
+  if (env.TERM === 'dumb') {
+    return min;
+  }
+
+  return min;
+}
+
+function getSupportLevel(stream) {
+  var level = supportsColor(stream);
+  return translateLevel(level);
+}
+
+module.exports = {
+  supportsColor: getSupportLevel,
+  stdout: getSupportLevel(process.stdout),
+  stderr: getSupportLevel(process.stderr),
+};

ProbeApi/Node_modules-temp/@colors/colors/package.json

@@ -0,0 +1,45 @@
+{
+    "name": "@colors/colors",
+    "description": "get colors in your node.js console",
+    "version": "1.5.0",
+    "author": "DABH",
+    "contributors": [
+        {
+            "name": "DABH",
+            "url": "https://github.com/DABH"
+        }
+    ],
+    "homepage": "https://github.com/DABH/colors.js",
+    "bugs": "https://github.com/DABH/colors.js/issues",
+    "keywords": [
+        "ansi",
+        "terminal",
+        "colors"
+    ],
+    "repository": {
+        "type": "git",
+        "url": "http://github.com/DABH/colors.js.git"
+    },
+    "license": "MIT",
+    "scripts": {
+        "lint": "eslint . --fix",
+        "test": "export FORCE_COLOR=1 && node tests/basic-test.js && node tests/safe-test.js"
+    },
+    "engines": {
+        "node": ">=0.1.90"
+    },
+    "main": "lib/index.js",
+    "files": [
+        "examples",
+        "lib",
+        "LICENSE",
+        "safe.js",
+        "themes",
+        "index.d.ts",
+        "safe.d.ts"
+    ],
+    "devDependencies": {
+        "eslint": "^5.2.0",
+        "eslint-config-google": "^0.11.0"
+    }
+}

ProbeApi/Node_modules-temp/@colors/colors/safe.d.ts

@@ -0,0 +1,48 @@
+// Type definitions for Colors.js 1.2
+// Project: https://github.com/Marak/colors.js
+// Definitions by: Bart van der Schoor <https://github.com/Bartvds>, Staffan Eketorp <https://github.com/staeke>
+// Definitions: https://github.com/Marak/colors.js
+
+export const enabled: boolean;
+export function enable(): void;
+export function disable(): void;
+export function setTheme(theme: any): void;
+
+export function strip(str: string): string;
+export function stripColors(str: string): string;
+
+export function black(str: string): string;
+export function red(str: string): string;
+export function green(str: string): string;
+export function yellow(str: string): string;
+export function blue(str: string): string;
+export function magenta(str: string): string;
+export function cyan(str: string): string;
+export function white(str: string): string;
+export function gray(str: string): string;
+export function grey(str: string): string;
+
+export function bgBlack(str: string): string;
+export function bgRed(str: string): string;
+export function bgGreen(str: string): string;
+export function bgYellow(str: string): string;
+export function bgBlue(str: string): string;
+export function bgMagenta(str: string): string;
+export function bgCyan(str: string): string;
+export function bgWhite(str: string): string;
+
+export function reset(str: string): string;
+export function bold(str: string): string;
+export function dim(str: string): string;
+export function italic(str: string): string;
+export function underline(str: string): string;
+export function inverse(str: string): string;
+export function hidden(str: string): string;
+export function strikethrough(str: string): string;
+
+export function rainbow(str: string): string;
+export function zebra(str: string): string;
+export function america(str: string): string;
+export function trap(str: string): string;
+export function random(str: string): string;
+export function zalgo(str: string): string;

ProbeApi/Node_modules-temp/@colors/colors/safe.js

@@ -0,0 +1,10 @@
+//
+// Remark: Requiring this file will use the "safe" colors API,
+// which will not touch String.prototype.
+//
+//   var colors = require('colors/safe');
+//   colors.red("foo")
+//
+//
+var colors = require('./lib/colors');
+module['exports'] = colors;

ProbeApi/Node_modules-temp/@colors/colors/themes/generic-logging.js

@@ -0,0 +1,12 @@
+module['exports'] = {
+  silly: 'rainbow',
+  input: 'grey',
+  verbose: 'cyan',
+  prompt: 'grey',
+  info: 'green',
+  data: 'grey',
+  help: 'cyan',
+  warn: 'yellow',
+  debug: 'blue',
+  error: 'red',
+};

ProbeApi/Node_modules-temp/@dabh/diagnostics/CHANGELOG.md

@@ -0,0 +1,26 @@
+# CHANGELOG
+
+### 2.0.2
+
+- Bump to kuler 2.0, which removes colornames as dependency, which we
+  never used. So smaller install size, less dependencies for all. 
+
+### 2.0.1
+
+- Use `storag-engine@3.0` which will automatically detect the correct
+  AsyncStorage implementation.
+- The upgrade also fixes a bug where it the `debug` and `diagnostics` values
+  to be JSON encoded instead of regular plain text.
+
+### 2.0.0
+
+- Documentation improvements.
+- Fixed a issue where async adapters were incorrectly detected.
+- Correctly inherit colors after applying colors the browser's console.
+
+### 2.0.0-alpha
+
+- Complete rewrite of all internals, now comes with separate builds for `browser`
+  `node` and `react-native` as well as dedicated builds for `production` and
+  `development` environments. Various utility methods and properties have
+  been added to the returned logger to make your lives even easier.

ProbeApi/Node_modules-temp/@dabh/diagnostics/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Arnout Kazemier, Martijn Swaagman, the Contributors.
+
+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.

ProbeApi/Node_modules-temp/@dabh/diagnostics/README.md

@@ -0,0 +1,473 @@
+# `diagnostics`
+
+Diagnostics in the evolution of debug pattern that is used in the Node.js core,  
+this extremely small but powerful technique can best be compared as feature
+flags for loggers. The created debug logger is disabled by default but can be
+enabled without changing a line of code, using flags.
+
+- Allows debugging in multiple JavaScript environments such as Node.js, browsers
+  and React-Native.
+- Separated development and production builds to minimize impact on your
+  application when bundled.
+- Allows for customization of logger, messages, and much more.
+
+![Output Example](example.png)
+
+## Installation
+
+The module is released in the public npm registry and can be installed by
+running:
+
+```
+npm install --save diagnostics
+```
+
+## Usage
+
+- [Introduction](#introduction)
+- [Advanced usage](#advanced-usage)
+  - [Production and development builds](#production-and-development-builds)
+    - [WebPack](#webpack)
+    - [Node.js](#nodejs)
+- [API](#api)
+  - [.enabled](#enabled)
+  - [.namespace](#namespace)
+  - [.dev/prod](#devprod)
+  - [set](#set)
+  - [modify](#modify)
+  - [use](#use)
+- [Modifiers](#modifiers)
+  - [namespace](#namespace-1)
+- [Adapters](#adapters)
+  - [process.env](#process-env)
+  - [hash](#hash)
+  - [localStorage](#localstorage)
+  - [AsyncStorage](#asyncstorage)
+- [Loggers](#loggers)
+
+### Introduction
+
+To create a new logger simply `require` the `diagnostics` module and call
+the returned function. It accepts 2 arguments:
+
+1. `namespace` **Required** This is the namespace of your logger so we know if we need to
+   enable your logger when a debug flag is used. Generally you use the name of
+   your library or application as first root namespace. For example if you're
+   building a parser in a library (example) you would set namespace
+   `example:parser`.
+2. `options` An object with additional configuration for the logger.
+   following keys are recognized:
+   - `force` Force the logger to be enabled.
+   - `colors` Colors are enabled by default for the logs, but you can set this
+     option to `false` to disable it.
+
+```js
+const debug = require('diagnostics')('foo:bar:baz');
+const debug = require('diagnostics')('foo:bar:baz', { options });
+
+debug('this is a log message %s', 'that will only show up when enabled');
+debug('that is pretty neat', { log: 'more', data: 1337 });
+```
+
+Unlike `console.log` statements that add and remove during your development
+lifecycle you create meaningful log statements that will give you insight in
+the library or application that you're developing.
+
+The created debugger uses different "adapters" to extract the debug flag
+out of the JavaScript environment. To learn more about enabling the debug flag
+in your specific environment click on one of the enabled adapters below.
+
+- **browser**: [localStorage](#localstorage), [hash](#hash)
+- **node.js**: [environment variables](#processenv)
+- **react-native**: [AsyncStorage](#asyncstorage)
+
+Please note that the returned logger is fully configured out of the box, you
+do not need to set any of the adapters/modifiers your self, they are there
+for when you want more advanced control over the process. But if you want to
+learn more about that, read the next section.
+
+### Advanced usage
+
+There are 2 specific usage patterns for `diagnostic`, library developers who
+implement it as part of their modules and applications developers who either
+use it in their application or are searching for ways to consume the messages.
+
+With the simple log interface as discussed in the [introduction](#introduction)
+section we make it easy for developers to add it as part of their libraries
+and applications, and with powerful [API](#api) we allow infinite customization
+by allowing custom adapters, loggers and modifiers to ensure that this library
+maintains relevant. These methods not only allow introduction of new loggers,
+but allow you think outside the box. For example you can maintain a history
+of past log messages, and output those when an uncaught exception happens in
+your application so you have additional context
+
+```js
+const diagnostics = require('diagnostics');
+
+let index = 0;
+const limit = 200;
+const history = new Array(limit);
+
+//
+// Force all `diagnostic` loggers to be enabled.
+//
+diagnostics.force = process.env.NODE_ENV === 'prod';
+diagnostics.set(function customLogger(meta, message) {
+  history[index]= { meta, message, now: Date.now() };
+  if (index++ === limit) index = 0;
+
+  //
+  // We're running a development build, so output.
+  //
+  if (meta.dev) console.log.apply(console, message);
+});
+
+process.on('uncaughtException', async function (err) {
+  await saveErrorToDisk(err, history);
+  process.exit(1);
+});
+```
+
+The small snippet above will maintain a 200 limited FIFO (First In First Out)
+queue of all debug messages that can be referenced when your application crashes
+
+#### Production and development builds
+
+When you `require` the `diagnostics` module you will be given a logger that is
+optimized for `development` so it can provide the best developer experience
+possible.
+
+The development logger enables all the [adapters](#adapters) for your
+JavaScript environment, adds a logger that outputs the messages to `console.log`
+and registers our message modifiers so log messages will be prefixed with the
+supplied namespace so you know where the log messages originates from.
+
+The development logger does not have any adapter, modifier and logger enabled
+by default. This ensures that your log messages never accidentally show up in
+production. However this does not mean that it's not possible to get debug
+messages in production. You can `force` the debugger to be enabled, and
+supply a [custom logger](#loggers).
+
+```js
+const diagnostics = require('diagnostics');
+const debug = debug('foo:bar', { force: true });
+
+//
+// Or enable _every_ diagnostic instance:
+//
+diagnostics.force = true;
+```
+
+##### WebPack
+
+WebPack has the concept of [mode](https://webpack.js.org/concepts/mode/#usage)'s
+which creates different
+
+```js
+module.exports = {
+  mode: 'development' // 'production'
+}
+```
+
+When you are building your app using the WebPack CLI you can use the `--mode`
+flag:
+
+```
+webpack --mode=production app.js -o /dist/bundle.js
+```
+
+##### Node.js
+
+When you are running your app using `Node.js` you should the `NODE_ENV`
+environment variable to `production` to ensure that you libraries that you
+import are optimized for production.
+
+```
+NODE_ENV=production node app.js
+```
+
+### API
+
+The returned logger exposes some addition properties that can be used used in
+your application or library:
+
+#### .enabled
+
+The returned logger will have a `.enabled` property assigned to it. This boolean
+can be used to check if the logger was enabled:
+
+```js
+const debug = require('diagnostics')('foo:bar');
+
+if (debug.enabled) {
+  //
+  // Do something special
+  //
+}
+```
+
+This property is exposed as:
+
+- Property on the logger.
+- Property on the meta/options object.
+
+#### .namespace
+
+This is the namespace that you originally provided to the function.
+
+```js
+const debug = require('diagnostics')('foo:bar');
+
+console.log(debug.namespace); // foo:bar
+```
+
+This property is exposed as:
+
+- Property on the logger.
+- Property on the meta/options object.
+
+#### .dev/prod
+
+There are different builds available of `diagnostics`, when you create a
+production build of your application using `NODE_ENV=production` you will be
+given an optimized, smaller build of `diagnostics` to reduce your bundle size.
+The `dev` and `prod` booleans on the returned logger indicate if you have a
+production or development version of the logger.
+
+```js
+const debug = require('diagnostics')('foo:bar');
+
+if (debug.prod) {
+  // do stuff
+}
+```
+
+This property is exposed as:
+
+- Property on the logger.
+- Property on the meta/options object.
+
+#### set
+
+Sets a new logger as default for  **all** `diagnostic` instances. The passed
+argument should be a function that write the log messages to where ever you
+want. It receives 2 arguments:
+
+1. `meta` An object with all the options that was provided to the original
+   logger that wants to write the log message as well as properties of the
+   debugger such as `prod`, `dev`, `namespace`, `enabled`. See [API](#api) for
+   all exposed properties.
+2. `args` An array of the log messages that needs to be written.
+
+```js
+const debug = require('diagnostics')('foo:more:namespaces');
+
+debug.use(function logger(meta, args) {
+  console.log(meta);
+  console.debug(...args);
+});
+```
+
+This method is exposed as:
+
+- Method on the logger.
+- Method on the meta/options object.
+- Method on `diagnostics` module.
+
+#### modify
+
+The modify method allows you add a new message modifier to **all** `diagnostic`
+instances. The passed argument should be a function that returns the passed
+message after modification. The function receives 2 arguments:
+
+1. `message`, Array, the log message.
+2. `options`, Object, the options that were passed into the logger when it was
+   initially created.
+
+```js
+const debug = require('diagnostics')('example:modifiers');
+
+debug.modify(function (message, options) {
+  return messages;
+});
+```
+
+This method is exposed as:
+
+- Method on the logger.
+- Method on the meta/options object.
+- Method on `diagnostics` module.
+
+See [modifiers](#modifiers) for more information.
+
+#### use
+
+Adds a new `adapter` to **all** `diagnostic` instances. The passed argument
+should be a function returns a boolean that indicates if the passed in
+`namespace` is allowed to write log messages.
+
+```js
+const diagnostics = require('diagnostics');
+const debug = diagnostics('foo:bar');
+
+debug.use(function (namespace) {
+  return namespace === 'foo:bar';
+});
+```
+
+This method is exposed as:
+
+- Method on the logger.
+- Method on the meta/options object.
+- Method on `diagnostics` module.
+
+See [adapters](#adapters) for more information.
+
+### Modifiers
+
+To be as flexible as possible when it comes to transforming messages we've
+come up with the concept of `modifiers` which can enhance the debug messages.
+This allows you to introduce functionality or details that you find important
+for debug messages, and doesn't require us to add additional bloat to the
+`diagnostic` core.
+
+For example, you want the messages to be prefixed with the date-time of when
+the log message occured:
+
+```js
+const diagnostics = require('diagnostics');
+
+diagnostics.modify(function datetime(args, options) {
+  args.unshift(new Date());
+  return args;
+});
+```
+
+Now all messages will be prefixed with date that is outputted by `new Date()`.
+The following modifiers are shipped with `diagnostics` and are enabled in
+**development** mode only:
+
+- [namespace](#namespace)
+
+#### namespace
+
+This modifier is enabled for all debug instances and prefixes the messages
+with the name of namespace under which it is logged. The namespace is colored
+using the `colorspace` module which groups similar namespaces under the same
+colorspace. You can have multiple namespaces for the debuggers where each
+namespace should be separated by a `:`
+
+```
+foo
+foo:bar
+foo:bar:baz
+```
+
+For console based output the `namespace-ansi` is used.
+
+### Adapters
+
+Adapters allows `diagnostics` to pull the `DEBUG` and `DIAGNOSTICS` environment
+variables from different sources. Not every JavaScript environment has a
+`process.env` that we can leverage. Adapters allows us to have different
+adapters for different environments. It means you can write your own custom
+adapter if needed as well.
+
+The `adapter` function should be passed a function as argument, this function
+will receive the `namespace` of a logger as argument and it should return a
+boolean that indicates if that logger should be enabled or not.
+
+```js
+const debug = require('diagnostics')('example:namespace');
+
+debug.adapter(require('diagnostics/adapters/localstorage'));
+```
+
+The modifiers are only enabled for `development`. The following adapters are
+available are available:
+
+#### process.env
+
+This adapter is enabled for `node.js`.
+
+Uses the `DEBUG` or `DIAGNOSTICS` (both are recognized) environment variables to
+pass in debug flag:
+
+**UNIX/Linux/Mac**
+```
+DEBUG=foo* node index.js
+```
+
+Using environment variables on Windows is a bit different, and also depends on
+toolchain you are using:
+
+**Windows**
+```
+set DEBUG=foo* & node index.js
+```
+
+**Powershell**
+```
+$env:DEBUG='foo*';node index.js
+```
+
+#### hash
+
+This adapter is enabled for `browsers`.
+
+This adapter uses the `window.location.hash` of as source for the environment
+variables. It assumes that hash is formatted using the same syntax as query
+strings:
+
+```js
+http://example.com/foo/bar#debug=foo*
+```
+
+It triggers on both the `debug=` and `diagnostics=` names.
+
+#### localStorage
+
+This adapter is enabled for `browsers`.
+
+This adapter uses the `localStorage` of the browser to store the debug flags.
+You can set the debug flag your self in your application code, but you can
+also open browser WebInspector and enable it through the console.
+
+```js
+localStorage.setItem('debug', 'foo*');
+```
+
+It triggers on both the `debug` and `diagnostics` storage items. (Please note
+that these keys should be entered in lowercase)
+
+#### AsyncStorage
+
+This adapter is enabled for `react-native`.
+
+This adapter uses the `AsyncStorage` API that is exposed by the `react-native`
+library to store and read the `debug` or `diagnostics` storage items.
+
+```js
+import { AsyncStorage } from 'react-native';
+
+AsyncStorage.setItem('debug', 'foo*');
+```
+
+Unlike other adapters, this is the only adapter that is `async` so that means
+that we're not able to instantly determine if a created logger should be
+enabled or disabled. So when a logger is created in `react-native` we initially
+assume it's disabled, any message that send during period will be queued
+internally.
+
+Once we've received the data from the `AsyncStorage` API we will determine
+if the logger should be enabled, flush the queued messages if needed and set
+all `enabled` properties accordingly on the returned logger.
+
+### Loggers
+
+By default it will log all messages to `console.log` in when the logger is
+enabled using the debug flag that is set using one of the adapters.
+
+## License
+
+[MIT](LICENSE)

ProbeApi/Node_modules-temp/@dabh/diagnostics/adapters/hash.js

@@ -0,0 +1,11 @@
+var adapter = require('./');
+
+/**
+ * Extracts the values from process.env.
+ *
+ * @type {Function}
+ * @public
+ */
+module.exports = adapter(function hash() {
+  return /(debug|diagnostics)=([^&]+)/i.exec(window.location.hash)[2];
+});

ProbeApi/Node_modules-temp/@dabh/diagnostics/adapters/index.js

@@ -0,0 +1,18 @@
+var enabled = require('enabled');
+
+/**
+ * Creates a new Adapter.
+ *
+ * @param {Function} fn Function that returns the value.
+ * @returns {Function} The adapter logic.
+ * @public
+ */
+module.exports = function create(fn) {
+  return function adapter(namespace) {
+    try {
+      return enabled(namespace, fn());
+    } catch (e) { /* Any failure means that we found nothing */ }
+
+    return false;
+  };
+}

ProbeApi/Node_modules-temp/@dabh/diagnostics/adapters/localstorage.js

@@ -0,0 +1,11 @@
+var adapter = require('./');
+
+/**
+ * Extracts the values from process.env.
+ *
+ * @type {Function}
+ * @public
+ */
+module.exports = adapter(function storage() {
+  return localStorage.getItem('debug') || localStorage.getItem('diagnostics');
+});

ProbeApi/Node_modules-temp/@dabh/diagnostics/adapters/process.env.js

@@ -0,0 +1,11 @@
+var adapter = require('./');
+
+/**
+ * Extracts the values from process.env.
+ *
+ * @type {Function}
+ * @public
+ */
+module.exports = adapter(function processenv() {
+  return process.env.DEBUG || process.env.DIAGNOSTICS;
+});

ProbeApi/Node_modules-temp/@dabh/diagnostics/browser/development.js

@@ -0,0 +1,35 @@
+var create = require('../diagnostics');
+
+/**
+ * Create a new diagnostics logger.
+ *
+ * @param {String} namespace The namespace it should enable.
+ * @param {Object} options Additional options.
+ * @returns {Function} The logger.
+ * @public
+ */
+var diagnostics = create(function dev(namespace, options) {
+  options = options || {};
+  options.namespace = namespace;
+  options.prod = false;
+  options.dev = true;
+
+  if (!dev.enabled(namespace) && !(options.force || dev.force)) {
+    return dev.nope(options);
+  }
+
+  return dev.yep(options);
+});
+
+//
+// Configure the logger for the given environment.
+//
+diagnostics.modify(require('../modifiers/namespace'));
+diagnostics.use(require('../adapters/localstorage'));
+diagnostics.use(require('../adapters/hash'));
+diagnostics.set(require('../logger/console'));
+
+//
+// Expose the diagnostics logger.
+//
+module.exports = diagnostics;

ProbeApi/Node_modules-temp/@dabh/diagnostics/browser/index.js

@@ -0,0 +1,8 @@
+//
+// Select the correct build version depending on the environment.
+//
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./production.js');
+} else {
+  module.exports = require('./development.js');
+}

ProbeApi/Node_modules-temp/@dabh/diagnostics/browser/override.js

@@ -0,0 +1,6 @@
+var diagnostics = require('./');
+
+//
+// No way to override `debug` with `diagnostics` in the browser.
+//
+module.exports = diagnostics;

ProbeApi/Node_modules-temp/@dabh/diagnostics/browser/production.js

@@ -0,0 +1,24 @@
+var create = require('../diagnostics');
+
+/**
+ * Create a new diagnostics logger.
+ *
+ * @param {String} namespace The namespace it should enable.
+ * @param {Object} options Additional options.
+ * @returns {Function} The logger.
+ * @public
+ */
+var diagnostics = create(function prod(namespace, options) {
+  options = options || {};
+  options.namespace = namespace;
+  options.prod = true;
+  options.dev = false;
+
+  if (!(options.force || prod.force)) return prod.nope(options);
+  return prod.yep(options);
+});
+
+//
+// Expose the diagnostics logger.
+//
+module.exports = diagnostics;

ProbeApi/Node_modules-temp/@dabh/diagnostics/diagnostics.js

@@ -0,0 +1,212 @@
+/**
+ * Contains all configured adapters for the given environment.
+ *
+ * @type {Array}
+ * @public
+ */
+var adapters = [];
+
+/**
+ * Contains all modifier functions.
+ *
+ * @typs {Array}
+ * @public
+ */
+var modifiers = [];
+
+/**
+ * Our default logger.
+ *
+ * @public
+ */
+var logger = function devnull() {};
+
+/**
+ * Register a new adapter that will used to find environments.
+ *
+ * @param {Function} adapter A function that will return the possible env.
+ * @returns {Boolean} Indication of a successful add.
+ * @public
+ */
+function use(adapter) {
+  if (~adapters.indexOf(adapter)) return false;
+
+  adapters.push(adapter);
+  return true;
+}
+
+/**
+ * Assign a new log method.
+ *
+ * @param {Function} custom The log method.
+ * @public
+ */
+function set(custom) {
+  logger = custom;
+}
+
+/**
+ * Check if the namespace is allowed by any of our adapters.
+ *
+ * @param {String} namespace The namespace that needs to be enabled
+ * @returns {Boolean|Promise} Indication if the namespace is enabled by our adapters.
+ * @public
+ */
+function enabled(namespace) {
+  var async = [];
+
+  for (var i = 0; i < adapters.length; i++) {
+    if (adapters[i].async) {
+      async.push(adapters[i]);
+      continue;
+    }
+
+    if (adapters[i](namespace)) return true;
+  }
+
+  if (!async.length) return false;
+
+  //
+  // Now that we know that we Async functions, we know we run in an ES6
+  // environment and can use all the API's that they offer, in this case
+  // we want to return a Promise so that we can `await` in React-Native
+  // for an async adapter.
+  //
+  return new Promise(function pinky(resolve) {
+    Promise.all(
+      async.map(function prebind(fn) {
+        return fn(namespace);
+      })
+    ).then(function resolved(values) {
+      resolve(values.some(Boolean));
+    });
+  });
+}
+
+/**
+ * Add a new message modifier to the debugger.
+ *
+ * @param {Function} fn Modification function.
+ * @returns {Boolean} Indication of a successful add.
+ * @public
+ */
+function modify(fn) {
+  if (~modifiers.indexOf(fn)) return false;
+
+  modifiers.push(fn);
+  return true;
+}
+
+/**
+ * Write data to the supplied logger.
+ *
+ * @param {Object} meta Meta information about the log.
+ * @param {Array} args Arguments for console.log.
+ * @public
+ */
+function write() {
+  logger.apply(logger, arguments);
+}
+
+/**
+ * Process the message with the modifiers.
+ *
+ * @param {Mixed} message The message to be transformed by modifers.
+ * @returns {String} Transformed message.
+ * @public
+ */
+function process(message) {
+  for (var i = 0; i < modifiers.length; i++) {
+    message = modifiers[i].apply(modifiers[i], arguments);
+  }
+
+  return message;
+}
+
+/**
+ * Introduce options to the logger function.
+ *
+ * @param {Function} fn Calback function.
+ * @param {Object} options Properties to introduce on fn.
+ * @returns {Function} The passed function
+ * @public
+ */
+function introduce(fn, options) {
+  var has = Object.prototype.hasOwnProperty;
+
+  for (var key in options) {
+    if (has.call(options, key)) {
+      fn[key] = options[key];
+    }
+  }
+
+  return fn;
+}
+
+/**
+ * Nope, we're not allowed to write messages.
+ *
+ * @returns {Boolean} false
+ * @public
+ */
+function nope(options) {
+  options.enabled = false;
+  options.modify = modify;
+  options.set = set;
+  options.use = use;
+
+  return introduce(function diagnopes() {
+    return false;
+  }, options);
+}
+
+/**
+ * Yep, we're allowed to write debug messages.
+ *
+ * @param {Object} options The options for the process.
+ * @returns {Function} The function that does the logging.
+ * @public
+ */
+function yep(options) {
+  /**
+   * The function that receives the actual debug information.
+   *
+   * @returns {Boolean} indication that we're logging.
+   * @public
+   */
+  function diagnostics() {
+    var args = Array.prototype.slice.call(arguments, 0);
+
+    write.call(write, options, process(args, options));
+    return true;
+  }
+
+  options.enabled = true;
+  options.modify = modify;
+  options.set = set;
+  options.use = use;
+
+  return introduce(diagnostics, options);
+}
+
+/**
+ * Simple helper function to introduce various of helper methods to our given
+ * diagnostics function.
+ *
+ * @param {Function} diagnostics The diagnostics function.
+ * @returns {Function} diagnostics
+ * @public
+ */
+module.exports = function create(diagnostics) {
+  diagnostics.introduce = introduce;
+  diagnostics.enabled = enabled;
+  diagnostics.process = process;
+  diagnostics.modify = modify;
+  diagnostics.write = write;
+  diagnostics.nope = nope;
+  diagnostics.yep = yep;
+  diagnostics.set = set;
+  diagnostics.use = use;
+
+  return diagnostics;
+}

ProbeApi/Node_modules-temp/@dabh/diagnostics/logger/console.js

@@ -0,0 +1,19 @@
+/**
+ * An idiot proof logger to be used as default. We've wrapped it in a try/catch
+ * statement to ensure the environments without the `console` API do not crash
+ * as well as an additional fix for ancient browsers like IE8 where the
+ * `console.log` API doesn't have an `apply`, so we need to use the Function's
+ * apply functionality to apply the arguments.
+ *
+ * @param {Object} meta Options of the logger.
+ * @param {Array} messages The actuall message that needs to be logged.
+ * @public
+ */
+module.exports = function (meta, messages) {
+  //
+  // So yea. IE8 doesn't have an apply so we need a work around to puke the
+  // arguments in place.
+  //
+  try { Function.prototype.apply.call(console.log, console, messages); }
+  catch (e) {}
+}

ProbeApi/Node_modules-temp/@dabh/diagnostics/modifiers/namespace-ansi.js

@@ -0,0 +1,20 @@
+var colorspace = require('colorspace');
+var kuler = require('kuler');
+
+/**
+ * Prefix the messages with a colored namespace.
+ *
+ * @param {Array} args The messages array that is getting written.
+ * @param {Object} options Options for diagnostics.
+ * @returns {Array} Altered messages array.
+ * @public
+ */
+module.exports = function ansiModifier(args, options) {
+  var namespace = options.namespace;
+  var ansi = options.colors !== false
+  ? kuler(namespace +':', colorspace(namespace))
+  : namespace +':';
+
+  args[0] = ansi +' '+ args[0];
+  return args;
+};

ProbeApi/Node_modules-temp/@dabh/diagnostics/modifiers/namespace.js

@@ -0,0 +1,32 @@
+var colorspace = require('colorspace');
+
+/**
+ * Prefix the messages with a colored namespace.
+ *
+ * @param {Array} messages The messages array that is getting written.
+ * @param {Object} options Options for diagnostics.
+ * @returns {Array} Altered messages array.
+ * @public
+ */
+module.exports = function colorNamespace(args, options) {
+  var namespace = options.namespace;
+
+  if (options.colors === false) {
+    args[0] = namespace +': '+ args[0];
+    return args;
+  }
+
+  var color = colorspace(namespace);
+
+  //
+  // The console API supports a special %c formatter in browsers. This is used
+  // to style console messages with any CSS styling, in our case we want to
+  // use colorize the namespace for clarity. As these are formatters, and
+  // we need to inject our CSS string as second messages argument so it
+  // gets picked up correctly.
+  //
+  args[0] = '%c'+ namespace +':%c '+ args[0];
+  args.splice(1, 0, 'color:'+ color, 'color:inherit');
+
+  return args;
+};

ProbeApi/Node_modules-temp/@dabh/diagnostics/node/development.js

@@ -0,0 +1,36 @@
+var create = require('../diagnostics');
+var tty = require('tty').isatty(1);
+
+/**
+ * Create a new diagnostics logger.
+ *
+ * @param {String} namespace The namespace it should enable.
+ * @param {Object} options Additional options.
+ * @returns {Function} The logger.
+ * @public
+ */
+var diagnostics = create(function dev(namespace, options) {
+  options = options || {};
+  options.colors = 'colors' in options ? options.colors : tty;
+  options.namespace = namespace;
+  options.prod = false;
+  options.dev = true;
+
+  if (!dev.enabled(namespace) && !(options.force || dev.force)) {
+    return dev.nope(options);
+  }
+  
+  return dev.yep(options);
+});
+
+//
+// Configure the logger for the given environment.
+//
+diagnostics.modify(require('../modifiers/namespace-ansi'));
+diagnostics.use(require('../adapters/process.env'));
+diagnostics.set(require('../logger/console'));
+
+//
+// Expose the diagnostics logger.
+//
+module.exports = diagnostics;

ProbeApi/Node_modules-temp/@dabh/diagnostics/node/index.js

@@ -0,0 +1,8 @@
+//
+// Select the correct build version depending on the environment.
+//
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./production.js');
+} else {
+  module.exports = require('./development.js');
+}

ProbeApi/Node_modules-temp/@dabh/diagnostics/node/override.js

@@ -0,0 +1,21 @@
+const diagnostics = require('./');
+
+//
+// Override the existing `debug` call so it will use `diagnostics` instead
+// of the `debug` module.
+//
+try {
+  var key = require.resolve('debug');
+
+  require.cache[key] = {
+    exports: diagnostics,
+    filename: key,
+    loaded: true,
+    id: key
+  };
+} catch (e) { /* We don't really care if it fails */ }
+
+//
+// Export the default import as exports again.
+//
+module.exports = diagnostics;

ProbeApi/Node_modules-temp/@dabh/diagnostics/node/production.js

@@ -0,0 +1,24 @@
+var create = require('../diagnostics');
+
+/**
+ * Create a new diagnostics logger.
+ *
+ * @param {String} namespace The namespace it should enable.
+ * @param {Object} options Additional options.
+ * @returns {Function} The logger.
+ * @public
+ */
+var diagnostics = create(function prod(namespace, options) {
+  options = options || {};
+  options.namespace = namespace;
+  options.prod = true;
+  options.dev = false;
+
+  if (!(options.force || prod.force)) return prod.nope(options);
+  return prod.yep(options);
+});
+
+//
+// Expose the diagnostics logger.
+//
+module.exports = diagnostics;

ProbeApi/Node_modules-temp/@dabh/diagnostics/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@dabh/diagnostics",
+  "version": "2.0.2",
+  "description": "Tools for debugging your node.js modules and event loop",
+  "main": "./node",
+  "browser": "./browser",
+  "scripts": {
+    "test:basic": "mocha --require test/mock.js test/*.test.js",
+    "test:node": "mocha --require test/mock test/node.js",
+    "test:browser": "mocha --require test/mock test/browser.js",
+    "test:runner": "npm run test:basic && npm run test:node && npm run test:browser",
+    "webpack:node:prod": "webpack --mode=production node/index.js -o /dev/null --json | webpack-bundle-size-analyzer",
+    "webpack:node:dev": "webpack --mode=development node/index.js -o /dev/null --json | webpack-bundle-size-analyzer",
+    "webpack:browser:prod": "webpack --mode=production browser/index.js -o /dev/null --json | webpack-bundle-size-analyzer",
+    "webpack:browser:dev": "webpack --mode=development browser/index.js -o /dev/null --json | webpack-bundle-size-analyzer",
+    "test": "nyc --reporter=text --reporter=lcov npm run test:runner"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/3rd-Eden/diagnostics.git"
+  },
+  "keywords": [
+    "debug",
+    "debugger",
+    "debugging",
+    "diagnostic",
+    "diagnostics",
+    "event",
+    "loop",
+    "metrics",
+    "stats"
+  ],
+  "author": "Arnout Kazemier",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/3rd-Eden/diagnostics/issues"
+  },
+  "homepage": "https://github.com/3rd-Eden/diagnostics",
+  "devDependencies": {
+    "assume": "2.1.x",
+    "asyncstorageapi": "^1.0.2",
+    "mocha": "5.2.x",
+    "nyc": "^14.1.1",
+    "objstorage": "^1.0.0",
+    "pre-commit": "1.2.x",
+    "require-poisoning": "^2.0.0",
+    "webpack": "^4.29.5",
+    "webpack-bundle-size-analyzer": "^3.0.0",
+    "webpack-cli": "^3.2.3"
+  },
+  "dependencies": {
+    "colorspace": "1.1.x",
+    "enabled": "2.0.x",
+    "kuler": "^2.0.0"
+  },
+  "contributors": [
+    "Martijn Swaagman (https://github.com/swaagie)",
+    "Jarrett Cruger (https://github.com/jcrugzz)",
+    "Sevastos (https://github.com/sevastos)"
+  ],
+  "directories": {
+    "test": "test"
+  }
+}

ProbeApi/Node_modules-temp/@types/body-parser/LICENSE

@@ -0,0 +1,21 @@
+    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

ProbeApi/Node_modules-temp/@types/body-parser/README.md

@@ -0,0 +1,16 @@
+# Installation
+> `npm install --save @types/body-parser`
+
+# Summary
+This package contains type definitions for body-parser (https://github.com/expressjs/body-parser).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/body-parser.
+
+### Additional Details
+ * Last updated: Tue, 16 Nov 2021 18:31:30 GMT
+ * Dependencies: [@types/connect](https://npmjs.com/package/@types/connect), [@types/node](https://npmjs.com/package/@types/node)
+ * Global values: none
+
+# Credits
+These definitions were written by [Santi Albo](https://github.com/santialbo), [Vilic Vane](https://github.com/vilic), [Jonathan Häberle](https://github.com/dreampulse), [Gevik Babakhani](https://github.com/blendsdk), [Tomasz Łaziuk](https://github.com/tlaziuk), [Jason Walton](https://github.com/jwalton), and [Piotr Błażejewicz](https://github.com/peterblazejewicz).

ProbeApi/Node_modules-temp/@types/body-parser/index.d.ts

@@ -0,0 +1,107 @@
+// Type definitions for body-parser 1.19
+// Project: https://github.com/expressjs/body-parser
+// Definitions by: Santi Albo <https://github.com/santialbo>
+//                 Vilic Vane <https://github.com/vilic>
+//                 Jonathan Häberle <https://github.com/dreampulse>
+//                 Gevik Babakhani <https://github.com/blendsdk>
+//                 Tomasz Łaziuk <https://github.com/tlaziuk>
+//                 Jason Walton <https://github.com/jwalton>
+//                 Piotr Błażejewicz <https://github.com/peterblazejewicz>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/// <reference types="node" />
+
+import { NextHandleFunction } from 'connect';
+import * as http from 'http';
+
+// for docs go to https://github.com/expressjs/body-parser/tree/1.19.0#body-parser
+
+declare namespace bodyParser {
+    interface BodyParser {
+        /**
+         * @deprecated  use individual json/urlencoded middlewares
+         */
+        (options?: OptionsJson & OptionsText & OptionsUrlencoded): NextHandleFunction;
+        /**
+         * Returns middleware that only parses json and only looks at requests
+         * where the Content-Type header matches the type option.
+         */
+        json(options?: OptionsJson): NextHandleFunction;
+        /**
+         * Returns middleware that parses all bodies as a Buffer and only looks at requests
+         * where the Content-Type header matches the type option.
+         */
+        raw(options?: Options): NextHandleFunction;
+
+        /**
+         * Returns middleware that parses all bodies as a string and only looks at requests
+         * where the Content-Type header matches the type option.
+         */
+        text(options?: OptionsText): NextHandleFunction;
+        /**
+         * Returns middleware that only parses urlencoded bodies and only looks at requests
+         * where the Content-Type header matches the type option
+         */
+        urlencoded(options?: OptionsUrlencoded): NextHandleFunction;
+    }
+
+    interface Options {
+        /** When set to true, then deflated (compressed) bodies will be inflated; when false, deflated bodies are rejected. Defaults to true. */
+        inflate?: boolean | undefined;
+        /**
+         * Controls the maximum request body size. If this is a number,
+         * then the value specifies the number of bytes; if it is a string,
+         * the value is passed to the bytes library for parsing. Defaults to '100kb'.
+         */
+        limit?: number | string | undefined;
+        /**
+         * The type option is used to determine what media type the middleware will parse
+         */
+        type?: string | string[] | ((req: http.IncomingMessage) => any) | undefined;
+        /**
+         * The verify option, if supplied, is called as verify(req, res, buf, encoding),
+         * where buf is a Buffer of the raw request body and encoding is the encoding of the request.
+         */
+        verify?(req: http.IncomingMessage, res: http.ServerResponse, buf: Buffer, encoding: string): void;
+    }
+
+    interface OptionsJson extends Options {
+        /**
+         *
+         * The reviver option is passed directly to JSON.parse as the second argument.
+         */
+        reviver?(key: string, value: any): any;
+        /**
+         * When set to `true`, will only accept arrays and objects;
+         * when `false` will accept anything JSON.parse accepts. Defaults to `true`.
+         */
+        strict?: boolean | undefined;
+    }
+
+    interface OptionsText extends Options {
+        /**
+         * Specify the default character set for the text content if the charset
+         * is not specified in the Content-Type header of the request.
+         * Defaults to `utf-8`.
+         */
+        defaultCharset?: string | undefined;
+    }
+
+    interface OptionsUrlencoded extends Options {
+        /**
+         * The extended option allows to choose between parsing the URL-encoded data
+         * with the querystring library (when `false`) or the qs library (when `true`).
+         */
+        extended?: boolean | undefined;
+        /**
+         * The parameterLimit option controls the maximum number of parameters
+         * that are allowed in the URL-encoded data. If a request contains more parameters than this value,
+         * a 413 will be returned to the client. Defaults to 1000.
+         */
+        parameterLimit?: number | undefined;
+    }
+}
+
+declare const bodyParser: bodyParser.BodyParser;
+
+export = bodyParser;

ProbeApi/Node_modules-temp/@types/body-parser/package.json

@@ -0,0 +1,58 @@
+{
+    "name": "@types/body-parser",
+    "version": "1.19.2",
+    "description": "TypeScript definitions for body-parser",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/body-parser",
+    "license": "MIT",
+    "contributors": [
+        {
+            "name": "Santi Albo",
+            "url": "https://github.com/santialbo",
+            "githubUsername": "santialbo"
+        },
+        {
+            "name": "Vilic Vane",
+            "url": "https://github.com/vilic",
+            "githubUsername": "vilic"
+        },
+        {
+            "name": "Jonathan Häberle",
+            "url": "https://github.com/dreampulse",
+            "githubUsername": "dreampulse"
+        },
+        {
+            "name": "Gevik Babakhani",
+            "url": "https://github.com/blendsdk",
+            "githubUsername": "blendsdk"
+        },
+        {
+            "name": "Tomasz Łaziuk",
+            "url": "https://github.com/tlaziuk",
+            "githubUsername": "tlaziuk"
+        },
+        {
+            "name": "Jason Walton",
+            "url": "https://github.com/jwalton",
+            "githubUsername": "jwalton"
+        },
+        {
+            "name": "Piotr Błażejewicz",
+            "url": "https://github.com/peterblazejewicz",
+            "githubUsername": "peterblazejewicz"
+        }
+    ],
+    "main": "",
+    "types": "index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+        "directory": "types/body-parser"
+    },
+    "scripts": {},
+    "dependencies": {
+        "@types/connect": "*",
+        "@types/node": "*"
+    },
+    "typesPublisherContentHash": "ad069aa8b9e8a95f66df025de11975c773540e4071000abdb7db565579b013ee",
+    "typeScriptVersion": "3.7"
+}

ProbeApi/Node_modules-temp/@types/connect/LICENSE

@@ -0,0 +1,21 @@
+    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

ProbeApi/Node_modules-temp/@types/connect/README.md

@@ -0,0 +1,16 @@
+# Installation
+> `npm install --save @types/connect`
+
+# Summary
+This package contains type definitions for connect (https://github.com/senchalabs/connect).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/connect.
+
+### Additional Details
+ * Last updated: Tue, 06 Jul 2021 20:32:28 GMT
+ * Dependencies: [@types/node](https://npmjs.com/package/@types/node)
+ * Global values: none
+
+# Credits
+These definitions were written by [Maxime LUCE](https://github.com/SomaticIT), and [Evan Hahn](https://github.com/EvanHahn).

ProbeApi/Node_modules-temp/@types/connect/index.d.ts

@@ -0,0 +1,93 @@
+// Type definitions for connect v3.4.0
+// Project: https://github.com/senchalabs/connect
+// Definitions by: Maxime LUCE <https://github.com/SomaticIT>
+//                 Evan Hahn <https://github.com/EvanHahn>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/// <reference types="node" />
+
+
+import * as http from "http";
+
+/**
+ * Create a new connect server.
+ */
+declare function createServer(): createServer.Server;
+
+declare namespace createServer {
+    export type ServerHandle = HandleFunction | http.Server;
+
+    export class IncomingMessage extends http.IncomingMessage {
+        originalUrl?: http.IncomingMessage["url"] | undefined;
+    }
+
+    type NextFunction = (err?: any) => void;
+
+    export type SimpleHandleFunction = (req: IncomingMessage, res: http.ServerResponse) => void;
+    export type NextHandleFunction = (req: IncomingMessage, res: http.ServerResponse, next: NextFunction) => void;
+    export type ErrorHandleFunction = (err: any, req: IncomingMessage, res: http.ServerResponse, next: NextFunction) => void;
+    export type HandleFunction = SimpleHandleFunction | NextHandleFunction | ErrorHandleFunction;
+
+    export interface ServerStackItem {
+        route: string;
+        handle: ServerHandle;
+    }
+
+    export interface Server extends NodeJS.EventEmitter {
+        (req: http.IncomingMessage, res: http.ServerResponse, next?: Function): void;
+
+        route: string;
+        stack: ServerStackItem[];
+
+        /**
+        * Utilize the given middleware `handle` to the given `route`,
+        * defaulting to _/_. This "route" is the mount-point for the
+        * middleware, when given a value other than _/_ the middleware
+        * is only effective when that segment is present in the request's
+        * pathname.
+        *
+        * For example if we were to mount a function at _/admin_, it would
+        * be invoked on _/admin_, and _/admin/settings_, however it would
+        * not be invoked for _/_, or _/posts_.
+        */
+        use(fn: NextHandleFunction): Server;
+        use(fn: HandleFunction): Server;
+        use(route: string, fn: NextHandleFunction): Server;
+        use(route: string, fn: HandleFunction): Server;
+
+        /**
+        * Handle server requests, punting them down
+        * the middleware stack.
+        */
+        handle(req: http.IncomingMessage, res: http.ServerResponse, next: Function): void;
+
+        /**
+        * Listen for connections.
+        *
+        * This method takes the same arguments
+        * as node's `http.Server#listen()`.
+        *
+        * HTTP and HTTPS:
+        *
+        * If you run your application both as HTTP
+        * and HTTPS you may wrap them individually,
+        * since your Connect "server" is really just
+        * a JavaScript `Function`.
+        *
+        *      var connect = require('connect')
+        *        , http = require('http')
+        *        , https = require('https');
+        *
+        *      var app = connect();
+        *
+        *      http.createServer(app).listen(80);
+        *      https.createServer(options, app).listen(443);
+        */
+        listen(port: number, hostname?: string, backlog?: number, callback?: Function): http.Server;
+        listen(port: number, hostname?: string, callback?: Function): http.Server;
+        listen(path: string, callback?: Function): http.Server;
+        listen(handle: any, listeningListener?: Function): http.Server;
+    }
+}
+
+export = createServer;

ProbeApi/Node_modules-temp/@types/connect/package.json

@@ -0,0 +1,32 @@
+{
+    "name": "@types/connect",
+    "version": "3.4.35",
+    "description": "TypeScript definitions for connect",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/connect",
+    "license": "MIT",
+    "contributors": [
+        {
+            "name": "Maxime LUCE",
+            "url": "https://github.com/SomaticIT",
+            "githubUsername": "SomaticIT"
+        },
+        {
+            "name": "Evan Hahn",
+            "url": "https://github.com/EvanHahn",
+            "githubUsername": "EvanHahn"
+        }
+    ],
+    "main": "",
+    "types": "index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+        "directory": "types/connect"
+    },
+    "scripts": {},
+    "dependencies": {
+        "@types/node": "*"
+    },
+    "typesPublisherContentHash": "09c0dcec5f675cb2bdd7487a85447955f769ef4ab174294478c4f055b528fecc",
+    "typeScriptVersion": "3.6"
+}

ProbeApi/Node_modules-temp/@types/cors/LICENSE

@@ -0,0 +1,21 @@
+    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

ProbeApi/Node_modules-temp/@types/cors/README.md

@@ -0,0 +1,78 @@
+# Installation
+> `npm install --save @types/cors`
+
+# Summary
+This package contains type definitions for cors (https://github.com/expressjs/cors/).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/cors.
+## [index.d.ts](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/cors/index.d.ts)
+````ts
+// Type definitions for cors 2.8
+// Project: https://github.com/expressjs/cors/
+// Definitions by: Alan Plum <https://github.com/pluma>
+//                 Gaurav Sharma <https://github.com/gtpan77>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.3
+
+import { IncomingHttpHeaders } from 'http';
+
+type StaticOrigin = boolean | string | RegExp | (boolean | string | RegExp)[];
+
+type CustomOrigin = (requestOrigin: string | undefined, callback: (err: Error | null, origin?: StaticOrigin) => void) => void;
+
+declare namespace e {
+    interface CorsRequest {
+        method?: string | undefined;
+        headers: IncomingHttpHeaders;
+    }
+    interface CorsOptions {
+        /**
+         * @default '*''
+         */
+        origin?: StaticOrigin | CustomOrigin | undefined;
+        /**
+         * @default 'GET,HEAD,PUT,PATCH,POST,DELETE'
+         */
+        methods?: string | string[] | undefined;
+        allowedHeaders?: string | string[] | undefined;
+        exposedHeaders?: string | string[] | undefined;
+        credentials?: boolean | undefined;
+        maxAge?: number | undefined;
+        /**
+         * @default false
+         */
+        preflightContinue?: boolean | undefined;
+        /**
+         * @default 204
+         */
+        optionsSuccessStatus?: number | undefined;
+    }
+    type CorsOptionsDelegate<T extends CorsRequest = CorsRequest> = (
+        req: T,
+        callback: (err: Error | null, options?: CorsOptions) => void,
+    ) => void;
+}
+
+declare function e<T extends e.CorsRequest = e.CorsRequest>(
+    options?: e.CorsOptions | e.CorsOptionsDelegate<T>,
+): (
+    req: T,
+    res: {
+        statusCode?: number | undefined;
+        setHeader(key: string, value: string): any;
+        end(): any;
+    },
+    next: (err?: any) => any,
+) => void;
+export = e;
+
+````
+
+### Additional Details
+ * Last updated: Fri, 09 Jul 2021 07:31:29 GMT
+ * Dependencies: none
+ * Global values: none
+
+# Credits
+These definitions were written by [Alan Plum](https://github.com/pluma), and [Gaurav Sharma](https://github.com/gtpan77).

ProbeApi/Node_modules-temp/@types/cors/index.d.ts

@@ -0,0 +1,58 @@
+// Type definitions for cors 2.8
+// Project: https://github.com/expressjs/cors/
+// Definitions by: Alan Plum <https://github.com/pluma>
+//                 Gaurav Sharma <https://github.com/gtpan77>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.3
+
+import { IncomingHttpHeaders } from 'http';
+
+type StaticOrigin = boolean | string | RegExp | (boolean | string | RegExp)[];
+
+type CustomOrigin = (requestOrigin: string | undefined, callback: (err: Error | null, origin?: StaticOrigin) => void) => void;
+
+declare namespace e {
+    interface CorsRequest {
+        method?: string | undefined;
+        headers: IncomingHttpHeaders;
+    }
+    interface CorsOptions {
+        /**
+         * @default '*''
+         */
+        origin?: StaticOrigin | CustomOrigin | undefined;
+        /**
+         * @default 'GET,HEAD,PUT,PATCH,POST,DELETE'
+         */
+        methods?: string | string[] | undefined;
+        allowedHeaders?: string | string[] | undefined;
+        exposedHeaders?: string | string[] | undefined;
+        credentials?: boolean | undefined;
+        maxAge?: number | undefined;
+        /**
+         * @default false
+         */
+        preflightContinue?: boolean | undefined;
+        /**
+         * @default 204
+         */
+        optionsSuccessStatus?: number | undefined;
+    }
+    type CorsOptionsDelegate<T extends CorsRequest = CorsRequest> = (
+        req: T,
+        callback: (err: Error | null, options?: CorsOptions) => void,
+    ) => void;
+}
+
+declare function e<T extends e.CorsRequest = e.CorsRequest>(
+    options?: e.CorsOptions | e.CorsOptionsDelegate<T>,
+): (
+    req: T,
+    res: {
+        statusCode?: number | undefined;
+        setHeader(key: string, value: string): any;
+        end(): any;
+    },
+    next: (err?: any) => any,
+) => void;
+export = e;

ProbeApi/Node_modules-temp/@types/cors/package.json

@@ -0,0 +1,30 @@
+{
+    "name": "@types/cors",
+    "version": "2.8.12",
+    "description": "TypeScript definitions for cors",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/cors",
+    "license": "MIT",
+    "contributors": [
+        {
+            "name": "Alan Plum",
+            "url": "https://github.com/pluma",
+            "githubUsername": "pluma"
+        },
+        {
+            "name": "Gaurav Sharma",
+            "url": "https://github.com/gtpan77",
+            "githubUsername": "gtpan77"
+        }
+    ],
+    "main": "",
+    "types": "index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+        "directory": "types/cors"
+    },
+    "scripts": {},
+    "dependencies": {},
+    "typesPublisherContentHash": "53ea51a6543d58d3c1b9035a9c361d8f06d7be01973be2895820b2fb7ad9563a",
+    "typeScriptVersion": "3.6"
+}

ProbeApi/Node_modules-temp/@types/express-serve-static-core/LICENSE

@@ -0,0 +1,21 @@
+    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

ProbeApi/Node_modules-temp/@types/express-serve-static-core/README.md

@@ -0,0 +1,16 @@
+# Installation
+> `npm install --save @types/express-serve-static-core`
+
+# Summary
+This package contains type definitions for Express (http://expressjs.com).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/express-serve-static-core.
+
+### Additional Details
+ * Last updated: Tue, 11 Jan 2022 22:31:38 GMT
+ * Dependencies: [@types/range-parser](https://npmjs.com/package/@types/range-parser), [@types/qs](https://npmjs.com/package/@types/qs), [@types/node](https://npmjs.com/package/@types/node)
+ * Global values: none
+
+# Credits
+These definitions were written by [Boris Yankov](https://github.com/borisyankov), [Satana Charuwichitratana](https://github.com/micksatana), [Sami Jaber](https://github.com/samijaber), [Jose Luis Leon](https://github.com/JoseLion), [David Stephens](https://github.com/dwrss), and [Shin Ando](https://github.com/andoshin11).

ProbeApi/Node_modules-temp/@types/express-serve-static-core/package.json

@@ -0,0 +1,61 @@
+{
+    "name": "@types/express-serve-static-core",
+    "version": "4.17.28",
+    "description": "TypeScript definitions for Express",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/express-serve-static-core",
+    "license": "MIT",
+    "contributors": [
+        {
+            "name": "Boris Yankov",
+            "url": "https://github.com/borisyankov",
+            "githubUsername": "borisyankov"
+        },
+        {
+            "name": "Satana Charuwichitratana",
+            "url": "https://github.com/micksatana",
+            "githubUsername": "micksatana"
+        },
+        {
+            "name": "Sami Jaber",
+            "url": "https://github.com/samijaber",
+            "githubUsername": "samijaber"
+        },
+        {
+            "name": "Jose Luis Leon",
+            "url": "https://github.com/JoseLion",
+            "githubUsername": "JoseLion"
+        },
+        {
+            "name": "David Stephens",
+            "url": "https://github.com/dwrss",
+            "githubUsername": "dwrss"
+        },
+        {
+            "name": "Shin Ando",
+            "url": "https://github.com/andoshin11",
+            "githubUsername": "andoshin11"
+        }
+    ],
+    "main": "",
+    "types": "index.d.ts",
+    "typesVersions": {
+        "<=4.0": {
+            "*": [
+                "ts4.0/*"
+            ]
+        }
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+        "directory": "types/express-serve-static-core"
+    },
+    "scripts": {},
+    "dependencies": {
+        "@types/node": "*",
+        "@types/qs": "*",
+        "@types/range-parser": "*"
+    },
+    "typesPublisherContentHash": "e8b75bce16c2593d8d5f9521ddcf5db42875f8406701ed9eca5178f1b74e91b9",
+    "typeScriptVersion": "3.8"
+}

ProbeApi/Node_modules-temp/@types/express/LICENSE

@@ -0,0 +1,21 @@
+    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

ProbeApi/Node_modules-temp/@types/express/README.md

@@ -0,0 +1,16 @@
+# Installation
+> `npm install --save @types/express`
+
+# Summary
+This package contains type definitions for Express (http://expressjs.com).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/express.
+
+### Additional Details
+ * Last updated: Tue, 06 Jul 2021 20:32:50 GMT
+ * Dependencies: [@types/body-parser](https://npmjs.com/package/@types/body-parser), [@types/serve-static](https://npmjs.com/package/@types/serve-static), [@types/express-serve-static-core](https://npmjs.com/package/@types/express-serve-static-core), [@types/qs](https://npmjs.com/package/@types/qs)
+ * Global values: none
+
+# Credits
+These definitions were written by [Boris Yankov](https://github.com/borisyankov), [China Medical University Hospital](https://github.com/CMUH), [Puneet Arora](https://github.com/puneetar), and [Dylan Frankland](https://github.com/dfrankland).

ProbeApi/Node_modules-temp/@types/express/index.d.ts

@@ -0,0 +1,133 @@
+// Type definitions for Express 4.17
+// Project: http://expressjs.com
+// Definitions by: Boris Yankov <https://github.com/borisyankov>
+//                 China Medical University Hospital <https://github.com/CMUH>
+//                 Puneet Arora <https://github.com/puneetar>
+//                 Dylan Frankland <https://github.com/dfrankland>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/* =================== USAGE ===================
+
+    import express = require("express");
+    var app = express();
+
+ =============================================== */
+
+/// <reference types="express-serve-static-core" />
+/// <reference types="serve-static" />
+
+import * as bodyParser from 'body-parser';
+import * as serveStatic from 'serve-static';
+import * as core from 'express-serve-static-core';
+import * as qs from 'qs';
+
+/**
+ * Creates an Express application. The express() function is a top-level function exported by the express module.
+ */
+declare function e(): core.Express;
+
+declare namespace e {
+    /**
+     * This is a built-in middleware function in Express. It parses incoming requests with JSON payloads and is based on body-parser.
+     * @since 4.16.0
+     */
+    var json: typeof bodyParser.json;
+
+    /**
+     * This is a built-in middleware function in Express. It parses incoming requests with Buffer payloads and is based on body-parser.
+     * @since 4.17.0
+     */
+    var raw: typeof bodyParser.raw;
+
+    /**
+     * This is a built-in middleware function in Express. It parses incoming requests with text payloads and is based on body-parser.
+     * @since 4.17.0
+     */
+    var text: typeof bodyParser.text;
+
+    /**
+     * These are the exposed prototypes.
+     */
+    var application: Application;
+    var request: Request;
+    var response: Response;
+
+    /**
+     * This is a built-in middleware function in Express. It serves static files and is based on serve-static.
+     */
+    var static: serveStatic.RequestHandlerConstructor<Response>;
+
+    /**
+     * This is a built-in middleware function in Express. It parses incoming requests with urlencoded payloads and is based on body-parser.
+     * @since 4.16.0
+     */
+    var urlencoded: typeof bodyParser.urlencoded;
+
+    /**
+     * This is a built-in middleware function in Express. It parses incoming request query parameters.
+     */
+    export function query(options: qs.IParseOptions | typeof qs.parse): Handler;
+
+    export function Router(options?: RouterOptions): core.Router;
+
+    interface RouterOptions {
+        /**
+         * Enable case sensitivity.
+         */
+        caseSensitive?: boolean | undefined;
+
+        /**
+         * Preserve the req.params values from the parent router.
+         * If the parent and the child have conflicting param names, the child’s value take precedence.
+         *
+         * @default false
+         * @since 4.5.0
+         */
+        mergeParams?: boolean | undefined;
+
+        /**
+         * Enable strict routing.
+         */
+        strict?: boolean | undefined;
+    }
+
+    interface Application extends core.Application {}
+    interface CookieOptions extends core.CookieOptions {}
+    interface Errback extends core.Errback {}
+    interface ErrorRequestHandler<
+        P = core.ParamsDictionary,
+        ResBody = any,
+        ReqBody = any,
+        ReqQuery = core.Query,
+        Locals extends Record<string, any> = Record<string, any>
+    > extends core.ErrorRequestHandler<P, ResBody, ReqBody, ReqQuery, Locals> {}
+    interface Express extends core.Express {}
+    interface Handler extends core.Handler {}
+    interface IRoute extends core.IRoute {}
+    interface IRouter extends core.IRouter {}
+    interface IRouterHandler<T> extends core.IRouterHandler<T> {}
+    interface IRouterMatcher<T> extends core.IRouterMatcher<T> {}
+    interface MediaType extends core.MediaType {}
+    interface NextFunction extends core.NextFunction {}
+    interface Request<
+        P = core.ParamsDictionary,
+        ResBody = any,
+        ReqBody = any,
+        ReqQuery = core.Query,
+        Locals extends Record<string, any> = Record<string, any>
+    > extends core.Request<P, ResBody, ReqBody, ReqQuery, Locals> {}
+    interface RequestHandler<
+        P = core.ParamsDictionary,
+        ResBody = any,
+        ReqBody = any,
+        ReqQuery = core.Query,
+        Locals extends Record<string, any> = Record<string, any>
+    > extends core.RequestHandler<P, ResBody, ReqBody, ReqQuery, Locals> {}
+    interface RequestParamHandler extends core.RequestParamHandler {}
+    export interface Response<ResBody = any, Locals extends Record<string, any> = Record<string, any>>
+        extends core.Response<ResBody, Locals> {}
+    interface Router extends core.Router {}
+    interface Send extends core.Send {}
+}
+
+export = e;

ProbeApi/Node_modules-temp/@types/express/package.json

@@ -0,0 +1,52 @@
+{
+    "name": "@types/express",
+    "version": "4.17.13",
+    "description": "TypeScript definitions for Express",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/express",
+    "license": "MIT",
+    "contributors": [
+        {
+            "name": "Boris Yankov",
+            "url": "https://github.com/borisyankov",
+            "githubUsername": "borisyankov"
+        },
+        {
+            "name": "China Medical University Hospital",
+            "url": "https://github.com/CMUH",
+            "githubUsername": "CMUH"
+        },
+        {
+            "name": "Puneet Arora",
+            "url": "https://github.com/puneetar",
+            "githubUsername": "puneetar"
+        },
+        {
+            "name": "Dylan Frankland",
+            "url": "https://github.com/dfrankland",
+            "githubUsername": "dfrankland"
+        }
+    ],
+    "main": "",
+    "types": "index.d.ts",
+    "typesVersions": {
+        "<=4.0": {
+            "*": [
+                "ts4.0/*"
+            ]
+        }
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+        "directory": "types/express"
+    },
+    "scripts": {},
+    "dependencies": {
+        "@types/body-parser": "*",
+        "@types/express-serve-static-core": "^4.17.18",
+        "@types/qs": "*",
+        "@types/serve-static": "*"
+    },
+    "typesPublisherContentHash": "df0c9de39b435f4152916282f0ae9e98f0548d6b50f6bb6aedddc52e4e3f25a7",
+    "typeScriptVersion": "3.6"
+}

ProbeApi/Node_modules-temp/@types/express/ts4.0/index.d.ts

@@ -0,0 +1,118 @@
+/// <reference types="express-serve-static-core" />
+/// <reference types="serve-static" />
+
+import * as bodyParser from 'body-parser';
+import * as serveStatic from 'serve-static';
+import * as core from 'express-serve-static-core';
+import * as qs from 'qs';
+
+/**
+ * Creates an Express application. The express() function is a top-level function exported by the express module.
+ */
+declare function e(): core.Express;
+
+declare namespace e {
+    /**
+     * This is a built-in middleware function in Express. It parses incoming requests with JSON payloads and is based on body-parser.
+     * @since 4.16.0
+     */
+    var json: typeof bodyParser.json;
+
+    /**
+     * This is a built-in middleware function in Express. It parses incoming requests with Buffer payloads and is based on body-parser.
+     * @since 4.17.0
+     */
+    var raw: typeof bodyParser.raw;
+
+    /**
+     * This is a built-in middleware function in Express. It parses incoming requests with text payloads and is based on body-parser.
+     * @since 4.17.0
+     */
+    var text: typeof bodyParser.text;
+
+    /**
+     * These are the exposed prototypes.
+     */
+    var application: Application;
+    var request: Request;
+    var response: Response;
+
+    /**
+     * This is a built-in middleware function in Express. It serves static files and is based on serve-static.
+     */
+    var static: serveStatic.RequestHandlerConstructor<Response>;
+
+    /**
+     * This is a built-in middleware function in Express. It parses incoming requests with urlencoded payloads and is based on body-parser.
+     * @since 4.16.0
+     */
+    var urlencoded: typeof bodyParser.urlencoded;
+
+    /**
+     * This is a built-in middleware function in Express. It parses incoming request query parameters.
+     */
+    export function query(options: qs.IParseOptions | typeof qs.parse): Handler;
+
+    export function Router(options?: RouterOptions): core.Router;
+
+    interface RouterOptions {
+        /**
+         * Enable case sensitivity.
+         */
+        caseSensitive?: boolean;
+
+        /**
+         * Preserve the req.params values from the parent router.
+         * If the parent and the child have conflicting param names, the child’s value take precedence.
+         *
+         * @default false
+         * @since 4.5.0
+         */
+        mergeParams?: boolean;
+
+        /**
+         * Enable strict routing.
+         */
+        strict?: boolean;
+    }
+
+    interface Application extends core.Application {}
+    interface CookieOptions extends core.CookieOptions {}
+    interface Errback extends core.Errback {}
+    interface ErrorRequestHandler<
+        P = core.ParamsDictionary,
+        ResBody = any,
+        ReqBody = any,
+        ReqQuery = core.Query,
+        Locals extends Record<string, any> = Record<string, any>
+    > extends core.ErrorRequestHandler<P, ResBody, ReqBody, ReqQuery, Locals> {}
+    interface Express extends core.Express {}
+    interface Handler extends core.Handler {}
+    interface IRoute extends core.IRoute {}
+    interface IRouter extends core.IRouter {}
+    interface IRouterHandler<T> extends core.IRouterHandler<T> {}
+    interface IRouterMatcher<T> extends core.IRouterMatcher<T> {}
+    interface MediaType extends core.MediaType {}
+    interface NextFunction extends core.NextFunction {}
+    interface Request<
+        P = core.ParamsDictionary,
+        ResBody = any,
+        ReqBody = any,
+        ReqQuery = core.Query,
+        Locals extends Record<string, any> = Record<string, any>
+    > extends core.Request<P, ResBody, ReqBody, ReqQuery, Locals> {}
+    interface RequestHandler<
+        P = core.ParamsDictionary,
+        ResBody = any,
+        ReqBody = any,
+        ReqQuery = core.Query,
+        Locals extends Record<string, any> = Record<string, any>
+    > extends core.RequestHandler<P, ResBody, ReqBody, ReqQuery, Locals> {}
+    interface RequestParamHandler extends core.RequestParamHandler {}
+    export interface Response<ResBody = any, Locals extends Record<string, any> = Record<string, any>>
+        extends core.Response<ResBody, Locals> {}
+    interface Router extends core.Router {}
+    interface Send extends core.Send {}
+}
+
+export = e;

ProbeApi/Node_modules-temp/@types/mime/LICENSE

@@ -0,0 +1,21 @@
+    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

ProbeApi/Node_modules-temp/@types/mime/Mime.d.ts

@@ -0,0 +1,10 @@
+import { TypeMap } from "./index";
+
+export default class Mime {
+    constructor(mimes: TypeMap);
+
+    lookup(path: string, fallback?: string): string;
+    extension(mime: string): string | undefined;
+    load(filepath: string): void;
+    define(mimes: TypeMap): void;
+}

ProbeApi/Node_modules-temp/@types/mime/README.md

@@ -0,0 +1,16 @@
+# Installation
+> `npm install --save @types/mime`
+
+# Summary
+This package contains type definitions for mime (https://github.com/broofa/node-mime).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/mime/v1.
+
+### Additional Details
+ * Last updated: Mon, 18 Jan 2021 14:32:15 GMT
+ * Dependencies: none
+ * Global values: `mime`, `mimelite`
+
+# Credits
+These definitions were written by [Jeff Goddard](https://github.com/jedigo), and [Daniel Hritzkiv](https://github.com/dhritzkiv).

ProbeApi/Node_modules-temp/@types/mime/index.d.ts

@@ -0,0 +1,35 @@
+// Type definitions for mime 1.3
+// Project: https://github.com/broofa/node-mime
+// Definitions by: Jeff Goddard <https://github.com/jedigo>
+//                 Daniel Hritzkiv <https://github.com/dhritzkiv>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+// Originally imported from: https://github.com/soywiz/typescript-node-definitions/mime.d.ts
+
+export as namespace mime;
+
+export interface TypeMap { [key: string]: string[]; }
+
+/**
+ * Look up a mime type based on extension.
+ *
+ * If not found, uses the fallback argument if provided, and otherwise
+ * uses `default_type`.
+ */
+export function lookup(path: string, fallback?: string): string;
+/**
+ * Return a file extensions associated with a mime type.
+ */
+export function extension(mime: string): string | undefined;
+/**
+ * Load an Apache2-style ".types" file.
+ */
+export function load(filepath: string): void;
+export function define(mimes: TypeMap): void;
+
+export interface Charsets {
+    lookup(mime: string, fallback: string): string;
+}
+
+export const charsets: Charsets;
+export const default_type: string;

ProbeApi/Node_modules-temp/@types/mime/lite.d.ts

@@ -0,0 +1,7 @@
+import { default as Mime } from "./Mime";
+
+declare const mimelite: Mime;
+
+export as namespace mimelite;
+
+export = mimelite;