Init

Nodejs/node_modules/.bin/escodegen

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

Nodejs/node_modules/.bin/esgenerate

@@ -0,0 +1 @@
+../escodegen/bin/esgenerate.js

Nodejs/node_modules/.bin/esparse

@@ -0,0 +1 @@
+../esprima/bin/esparse.js

Nodejs/node_modules/.bin/esvalidate

@@ -0,0 +1 @@
+../esprima/bin/esvalidate.js

Nodejs/node_modules/.bin/mkdirp

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

Nodejs/node_modules/.bin/mqtt

@@ -0,0 +1 @@
+../mqtt/mqtt.js

Nodejs/node_modules/.bin/mqtt_pub

@@ -0,0 +1 @@
+../mqtt/bin/pub.js

Nodejs/node_modules/.bin/mqtt_sub

@@ -0,0 +1 @@
+../mqtt/bin/sub.js

Nodejs/node_modules/.bin/parser

@@ -0,0 +1 @@
+../@babel/parser/bin/babel-parser.js

Nodejs/node_modules/.bin/pkg

@@ -0,0 +1 @@
+../pkg/lib-es5/bin.js

Nodejs/node_modules/.bin/pkg-fetch

@@ -0,0 +1 @@
+../pkg-fetch/lib-es5/bin.js

Nodejs/node_modules/.bin/semver

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

Nodejs/node_modules/.bin/sshpk-conv

@@ -0,0 +1 @@
+../sshpk/bin/sshpk-conv

Nodejs/node_modules/.bin/sshpk-sign

@@ -0,0 +1 @@
+../sshpk/bin/sshpk-sign

Nodejs/node_modules/.bin/sshpk-verify

@@ -0,0 +1 @@
+../sshpk/bin/sshpk-verify

Nodejs/node_modules/.bin/uuid

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

Nodejs/node_modules/@babel/parser/LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2012-2014 by various contributors (see AUTHORS)
+
+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.

Nodejs/node_modules/@babel/parser/README.md

@@ -0,0 +1,19 @@
+# @babel/parser
+
+> A JavaScript parser
+
+See our website [@babel/parser](https://babeljs.io/docs/en/next/babel-parser.html) for more information or the [issues](https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A+parser+%28babylon%29%22+is%3Aopen) associated with this package.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save-dev @babel/parser
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/parser --dev
+```

Nodejs/node_modules/@babel/parser/bin/babel-parser.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+/* eslint no-var: 0 */
+
+var parser = require("..");
+var fs = require("fs");
+
+var filename = process.argv[2];
+if (!filename) {
+  console.error("no filename specified");
+} else {
+  var file = fs.readFileSync(filename, "utf8");
+  var ast = parser.parse(file);
+
+  console.log(JSON.stringify(ast, null, "  "));
+}

Nodejs/node_modules/@babel/parser/lib/options.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getOptions = getOptions;
+exports.defaultOptions = void 0;
+const defaultOptions = {
+  sourceType: "script",
+  sourceFilename: undefined,
+  startLine: 1,
+  allowAwaitOutsideFunction: false,
+  allowReturnOutsideFunction: false,
+  allowImportExportEverywhere: false,
+  allowSuperOutsideMethod: false,
+  allowUndeclaredExports: false,
+  plugins: [],
+  strictMode: null,
+  ranges: false,
+  tokens: false,
+  createParenthesizedExpressions: false,
+  errorRecovery: false
+};
+exports.defaultOptions = defaultOptions;
+
+function getOptions(opts) {
+  const options = {};
+
+  for (let _i = 0, _Object$keys = Object.keys(defaultOptions); _i < _Object$keys.length; _i++) {
+    const key = _Object$keys[_i];
+    options[key] = opts && opts[key] != null ? opts[key] : defaultOptions[key];
+  }
+
+  return options;
+}

Nodejs/node_modules/@babel/parser/lib/parser/base.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+class BaseParser {
+  constructor() {
+    this.sawUnambiguousESM = false;
+    this.ambiguousScriptDifferentAst = false;
+  }
+
+  hasPlugin(name) {
+    return this.plugins.has(name);
+  }
+
+  getPluginOption(plugin, name) {
+    if (this.hasPlugin(plugin)) return this.plugins.get(plugin)[name];
+  }
+
+}
+
+exports.default = BaseParser;

Nodejs/node_modules/@babel/parser/lib/parser/comments.js

@@ -0,0 +1,198 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _base = _interopRequireDefault(require("./base"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function last(stack) {
+  return stack[stack.length - 1];
+}
+
+class CommentsParser extends _base.default {
+  addComment(comment) {
+    if (this.filename) comment.loc.filename = this.filename;
+    this.state.trailingComments.push(comment);
+    this.state.leadingComments.push(comment);
+  }
+
+  adjustCommentsAfterTrailingComma(node, elements, takeAllComments) {
+    if (this.state.leadingComments.length === 0) {
+      return;
+    }
+
+    let lastElement = null;
+    let i = elements.length;
+
+    while (lastElement === null && i > 0) {
+      lastElement = elements[--i];
+    }
+
+    if (lastElement === null) {
+      return;
+    }
+
+    for (let j = 0; j < this.state.leadingComments.length; j++) {
+      if (this.state.leadingComments[j].end < this.state.commentPreviousNode.end) {
+        this.state.leadingComments.splice(j, 1);
+        j--;
+      }
+    }
+
+    const newTrailingComments = [];
+
+    for (let i = 0; i < this.state.leadingComments.length; i++) {
+      const leadingComment = this.state.leadingComments[i];
+
+      if (leadingComment.end < node.end) {
+        newTrailingComments.push(leadingComment);
+
+        if (!takeAllComments) {
+          this.state.leadingComments.splice(i, 1);
+          i--;
+        }
+      } else {
+        if (node.trailingComments === undefined) {
+          node.trailingComments = [];
+        }
+
+        node.trailingComments.push(leadingComment);
+      }
+    }
+
+    if (takeAllComments) this.state.leadingComments = [];
+
+    if (newTrailingComments.length > 0) {
+      lastElement.trailingComments = newTrailingComments;
+    } else if (lastElement.trailingComments !== undefined) {
+      lastElement.trailingComments = [];
+    }
+  }
+
+  processComment(node) {
+    if (node.type === "Program" && node.body.length > 0) return;
+    const stack = this.state.commentStack;
+    let firstChild, lastChild, trailingComments, i, j;
+
+    if (this.state.trailingComments.length > 0) {
+      if (this.state.trailingComments[0].start >= node.end) {
+        trailingComments = this.state.trailingComments;
+        this.state.trailingComments = [];
+      } else {
+        this.state.trailingComments.length = 0;
+      }
+    } else if (stack.length > 0) {
+      const lastInStack = last(stack);
+
+      if (lastInStack.trailingComments && lastInStack.trailingComments[0].start >= node.end) {
+        trailingComments = lastInStack.trailingComments;
+        delete lastInStack.trailingComments;
+      }
+    }
+
+    if (stack.length > 0 && last(stack).start >= node.start) {
+      firstChild = stack.pop();
+    }
+
+    while (stack.length > 0 && last(stack).start >= node.start) {
+      lastChild = stack.pop();
+    }
+
+    if (!lastChild && firstChild) lastChild = firstChild;
+
+    if (firstChild) {
+      switch (node.type) {
+        case "ObjectExpression":
+          this.adjustCommentsAfterTrailingComma(node, node.properties);
+          break;
+
+        case "ObjectPattern":
+          this.adjustCommentsAfterTrailingComma(node, node.properties, true);
+          break;
+
+        case "CallExpression":
+          this.adjustCommentsAfterTrailingComma(node, node.arguments);
+          break;
+
+        case "ArrayExpression":
+          this.adjustCommentsAfterTrailingComma(node, node.elements);
+          break;
+
+        case "ArrayPattern":
+          this.adjustCommentsAfterTrailingComma(node, node.elements, true);
+          break;
+      }
+    } else if (this.state.commentPreviousNode && (this.state.commentPreviousNode.type === "ImportSpecifier" && node.type !== "ImportSpecifier" || this.state.commentPreviousNode.type === "ExportSpecifier" && node.type !== "ExportSpecifier")) {
+      this.adjustCommentsAfterTrailingComma(node, [this.state.commentPreviousNode]);
+    }
+
+    if (lastChild) {
+      if (lastChild.leadingComments) {
+        if (lastChild !== node && lastChild.leadingComments.length > 0 && last(lastChild.leadingComments).end <= node.start) {
+          node.leadingComments = lastChild.leadingComments;
+          delete lastChild.leadingComments;
+        } else {
+          for (i = lastChild.leadingComments.length - 2; i >= 0; --i) {
+            if (lastChild.leadingComments[i].end <= node.start) {
+              node.leadingComments = lastChild.leadingComments.splice(0, i + 1);
+              break;
+            }
+          }
+        }
+      }
+    } else if (this.state.leadingComments.length > 0) {
+      if (last(this.state.leadingComments).end <= node.start) {
+        if (this.state.commentPreviousNode) {
+          for (j = 0; j < this.state.leadingComments.length; j++) {
+            if (this.state.leadingComments[j].end < this.state.commentPreviousNode.end) {
+              this.state.leadingComments.splice(j, 1);
+              j--;
+            }
+          }
+        }
+
+        if (this.state.leadingComments.length > 0) {
+          node.leadingComments = this.state.leadingComments;
+          this.state.leadingComments = [];
+        }
+      } else {
+        for (i = 0; i < this.state.leadingComments.length; i++) {
+          if (this.state.leadingComments[i].end > node.start) {
+            break;
+          }
+        }
+
+        const leadingComments = this.state.leadingComments.slice(0, i);
+
+        if (leadingComments.length) {
+          node.leadingComments = leadingComments;
+        }
+
+        trailingComments = this.state.leadingComments.slice(i);
+
+        if (trailingComments.length === 0) {
+          trailingComments = null;
+        }
+      }
+    }
+
+    this.state.commentPreviousNode = node;
+
+    if (trailingComments) {
+      if (trailingComments.length && trailingComments[0].start >= node.start && last(trailingComments).end <= node.end) {
+        node.innerComments = trailingComments;
+      } else {
+        node.trailingComments = trailingComments;
+      }
+    }
+
+    stack.push(node);
+  }
+
+}
+
+exports.default = CommentsParser;

Nodejs/node_modules/@babel/parser/lib/parser/index.js

@@ -0,0 +1,76 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _options = require("../options");
+
+var _statement = _interopRequireDefault(require("./statement"));
+
+var _scopeflags = require("../util/scopeflags");
+
+var _scope = _interopRequireDefault(require("../util/scope"));
+
+var _classScope = _interopRequireDefault(require("../util/class-scope"));
+
+var _productionParameter = _interopRequireWildcard(require("../util/production-parameter"));
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class Parser extends _statement.default {
+  constructor(options, input) {
+    options = (0, _options.getOptions)(options);
+    super(options, input);
+    const ScopeHandler = this.getScopeHandler();
+    this.options = options;
+    this.inModule = this.options.sourceType === "module";
+    this.scope = new ScopeHandler(this.raise.bind(this), this.inModule);
+    this.prodParam = new _productionParameter.default();
+    this.classScope = new _classScope.default(this.raise.bind(this));
+    this.plugins = pluginsMap(this.options.plugins);
+    this.filename = options.sourceFilename;
+  }
+
+  getScopeHandler() {
+    return _scope.default;
+  }
+
+  parse() {
+    let paramFlags = _productionParameter.PARAM;
+
+    if (this.hasPlugin("topLevelAwait") && this.inModule) {
+      paramFlags |= _productionParameter.PARAM_AWAIT;
+    }
+
+    this.scope.enter(_scopeflags.SCOPE_PROGRAM);
+    this.prodParam.enter(paramFlags);
+    const file = this.startNode();
+    const program = this.startNode();
+    this.nextToken();
+    file.errors = null;
+    this.parseTopLevel(file, program);
+    file.errors = this.state.errors;
+    return file;
+  }
+
+}
+
+exports.default = Parser;
+
+function pluginsMap(plugins) {
+  const pluginMap = new Map();
+
+  for (let _i = 0; _i < plugins.length; _i++) {
+    const plugin = plugins[_i];
+    const [name, options] = Array.isArray(plugin) ? plugin : [plugin, {}];
+    if (!pluginMap.has(name)) pluginMap.set(name, options || {});
+  }
+
+  return pluginMap;
+}

Nodejs/node_modules/@babel/parser/lib/parser/location.js

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _location = require("../util/location");
+
+var _comments = _interopRequireDefault(require("./comments"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class LocationParser extends _comments.default {
+  getLocationForPosition(pos) {
+    let loc;
+    if (pos === this.state.start) loc = this.state.startLoc;else if (pos === this.state.lastTokStart) loc = this.state.lastTokStartLoc;else if (pos === this.state.end) loc = this.state.endLoc;else if (pos === this.state.lastTokEnd) loc = this.state.lastTokEndLoc;else loc = (0, _location.getLineInfo)(this.input, pos);
+    return loc;
+  }
+
+  raise(pos, message, {
+    missingPluginNames,
+    code
+  } = {}) {
+    const loc = this.getLocationForPosition(pos);
+    message += ` (${loc.line}:${loc.column})`;
+    const err = new SyntaxError(message);
+    err.pos = pos;
+    err.loc = loc;
+
+    if (missingPluginNames) {
+      err.missingPlugin = missingPluginNames;
+    }
+
+    if (code !== undefined) {
+      err.code = code;
+    }
+
+    if (this.options.errorRecovery) {
+      if (!this.isLookahead) this.state.errors.push(err);
+      return err;
+    } else {
+      throw err;
+    }
+  }
+
+}
+
+exports.default = LocationParser;

Nodejs/node_modules/@babel/parser/lib/parser/lval.js

@@ -0,0 +1,361 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _types = require("../tokenizer/types");
+
+var _identifier = require("../util/identifier");
+
+var _node = require("./node");
+
+var _scopeflags = require("../util/scopeflags");
+
+var _util = require("./util");
+
+const unwrapParenthesizedExpression = node => {
+  return node.type === "ParenthesizedExpression" ? unwrapParenthesizedExpression(node.expression) : node;
+};
+
+class LValParser extends _node.NodeUtils {
+  toAssignable(node) {
+    var _node$extra, _node$extra3;
+
+    let parenthesized = undefined;
+
+    if (node.type === "ParenthesizedExpression" || ((_node$extra = node.extra) == null ? void 0 : _node$extra.parenthesized)) {
+      parenthesized = unwrapParenthesizedExpression(node);
+
+      if (parenthesized.type !== "Identifier" && parenthesized.type !== "MemberExpression") {
+        this.raise(node.start, "Invalid parenthesized assignment pattern");
+      }
+    }
+
+    switch (node.type) {
+      case "Identifier":
+      case "ObjectPattern":
+      case "ArrayPattern":
+      case "AssignmentPattern":
+        break;
+
+      case "ObjectExpression":
+        node.type = "ObjectPattern";
+
+        for (let i = 0, length = node.properties.length, last = length - 1; i < length; i++) {
+          var _node$extra2;
+
+          const prop = node.properties[i];
+          const isLast = i === last;
+          this.toAssignableObjectExpressionProp(prop, isLast);
+
+          if (isLast && prop.type === "RestElement" && ((_node$extra2 = node.extra) == null ? void 0 : _node$extra2.trailingComma)) {
+            this.raiseRestNotLast(node.extra.trailingComma);
+          }
+        }
+
+        break;
+
+      case "ObjectProperty":
+        this.toAssignable(node.value);
+        break;
+
+      case "SpreadElement":
+        {
+          this.checkToRestConversion(node);
+          node.type = "RestElement";
+          const arg = node.argument;
+          this.toAssignable(arg);
+          break;
+        }
+
+      case "ArrayExpression":
+        node.type = "ArrayPattern";
+        this.toAssignableList(node.elements, (_node$extra3 = node.extra) == null ? void 0 : _node$extra3.trailingComma);
+        break;
+
+      case "AssignmentExpression":
+        if (node.operator !== "=") {
+          this.raise(node.left.end, "Only '=' operator can be used for specifying default value.");
+        }
+
+        node.type = "AssignmentPattern";
+        delete node.operator;
+        this.toAssignable(node.left);
+        break;
+
+      case "ParenthesizedExpression":
+        this.toAssignable(parenthesized);
+        break;
+
+      default:
+    }
+
+    return node;
+  }
+
+  toAssignableObjectExpressionProp(prop, isLast) {
+    if (prop.type === "ObjectMethod") {
+      const error = prop.kind === "get" || prop.kind === "set" ? "Object pattern can't contain getter or setter" : "Object pattern can't contain methods";
+      this.raise(prop.key.start, error);
+    } else if (prop.type === "SpreadElement" && !isLast) {
+      this.raiseRestNotLast(prop.start);
+    } else {
+      this.toAssignable(prop);
+    }
+  }
+
+  toAssignableList(exprList, trailingCommaPos) {
+    let end = exprList.length;
+
+    if (end) {
+      const last = exprList[end - 1];
+
+      if (last && last.type === "RestElement") {
+        --end;
+      } else if (last && last.type === "SpreadElement") {
+        last.type = "RestElement";
+        const arg = last.argument;
+        this.toAssignable(arg);
+
+        if (arg.type !== "Identifier" && arg.type !== "MemberExpression" && arg.type !== "ArrayPattern" && arg.type !== "ObjectPattern") {
+          this.unexpected(arg.start);
+        }
+
+        if (trailingCommaPos) {
+          this.raiseTrailingCommaAfterRest(trailingCommaPos);
+        }
+
+        --end;
+      }
+    }
+
+    for (let i = 0; i < end; i++) {
+      const elt = exprList[i];
+
+      if (elt) {
+        this.toAssignable(elt);
+
+        if (elt.type === "RestElement") {
+          this.raiseRestNotLast(elt.start);
+        }
+      }
+    }
+
+    return exprList;
+  }
+
+  toReferencedList(exprList, isParenthesizedExpr) {
+    return exprList;
+  }
+
+  toReferencedListDeep(exprList, isParenthesizedExpr) {
+    this.toReferencedList(exprList, isParenthesizedExpr);
+
+    for (let _i = 0; _i < exprList.length; _i++) {
+      const expr = exprList[_i];
+
+      if (expr && expr.type === "ArrayExpression") {
+        this.toReferencedListDeep(expr.elements);
+      }
+    }
+  }
+
+  parseSpread(refExpressionErrors, refNeedsArrowPos) {
+    const node = this.startNode();
+    this.next();
+    node.argument = this.parseMaybeAssign(false, refExpressionErrors, undefined, refNeedsArrowPos);
+    return this.finishNode(node, "SpreadElement");
+  }
+
+  parseRestBinding() {
+    const node = this.startNode();
+    this.next();
+    node.argument = this.parseBindingAtom();
+    return this.finishNode(node, "RestElement");
+  }
+
+  parseBindingAtom() {
+    switch (this.state.type) {
+      case _types.types.bracketL:
+        {
+          const node = this.startNode();
+          this.next();
+          node.elements = this.parseBindingList(_types.types.bracketR, 93, true);
+          return this.finishNode(node, "ArrayPattern");
+        }
+
+      case _types.types.braceL:
+        return this.parseObj(true);
+    }
+
+    return this.parseIdentifier();
+  }
+
+  parseBindingList(close, closeCharCode, allowEmpty, allowModifiers) {
+    const elts = [];
+    let first = true;
+
+    while (!this.eat(close)) {
+      if (first) {
+        first = false;
+      } else {
+        this.expect(_types.types.comma);
+      }
+
+      if (allowEmpty && this.match(_types.types.comma)) {
+        elts.push(null);
+      } else if (this.eat(close)) {
+        break;
+      } else if (this.match(_types.types.ellipsis)) {
+        elts.push(this.parseAssignableListItemTypes(this.parseRestBinding()));
+        this.checkCommaAfterRest(closeCharCode);
+        this.expect(close);
+        break;
+      } else {
+        const decorators = [];
+
+        if (this.match(_types.types.at) && this.hasPlugin("decorators")) {
+          this.raise(this.state.start, "Stage 2 decorators cannot be used to decorate parameters");
+        }
+
+        while (this.match(_types.types.at)) {
+          decorators.push(this.parseDecorator());
+        }
+
+        elts.push(this.parseAssignableListItem(allowModifiers, decorators));
+      }
+    }
+
+    return elts;
+  }
+
+  parseAssignableListItem(allowModifiers, decorators) {
+    const left = this.parseMaybeDefault();
+    this.parseAssignableListItemTypes(left);
+    const elt = this.parseMaybeDefault(left.start, left.loc.start, left);
+
+    if (decorators.length) {
+      left.decorators = decorators;
+    }
+
+    return elt;
+  }
+
+  parseAssignableListItemTypes(param) {
+    return param;
+  }
+
+  parseMaybeDefault(startPos, startLoc, left) {
+    startLoc = startLoc || this.state.startLoc;
+    startPos = startPos || this.state.start;
+    left = left || this.parseBindingAtom();
+    if (!this.eat(_types.types.eq)) return left;
+    const node = this.startNodeAt(startPos, startLoc);
+    node.left = left;
+    node.right = this.parseMaybeAssign();
+    return this.finishNode(node, "AssignmentPattern");
+  }
+
+  checkLVal(expr, bindingType = _scopeflags.BIND_NONE, checkClashes, contextDescription, disallowLetBinding, strictModeChanged = false) {
+    switch (expr.type) {
+      case "Identifier":
+        if (this.state.strict && (strictModeChanged ? (0, _identifier.isStrictBindReservedWord)(expr.name, this.inModule) : (0, _identifier.isStrictBindOnlyReservedWord)(expr.name))) {
+          this.raise(expr.start, `${bindingType === _scopeflags.BIND_NONE ? "Assigning to" : "Binding"} '${expr.name}' in strict mode`);
+        }
+
+        if (checkClashes) {
+          const key = `_${expr.name}`;
+
+          if (checkClashes[key]) {
+            this.raise(expr.start, "Argument name clash");
+          } else {
+            checkClashes[key] = true;
+          }
+        }
+
+        if (disallowLetBinding && expr.name === "let") {
+          this.raise(expr.start, "'let' is not allowed to be used as a name in 'let' or 'const' declarations.");
+        }
+
+        if (!(bindingType & _scopeflags.BIND_NONE)) {
+          this.scope.declareName(expr.name, bindingType, expr.start);
+        }
+
+        break;
+
+      case "MemberExpression":
+        if (bindingType !== _scopeflags.BIND_NONE) {
+          this.raise(expr.start, "Binding member expression");
+        }
+
+        break;
+
+      case "ObjectPattern":
+        for (let _i2 = 0, _expr$properties = expr.properties; _i2 < _expr$properties.length; _i2++) {
+          let prop = _expr$properties[_i2];
+          if (prop.type === "ObjectProperty") prop = prop.value;else if (prop.type === "ObjectMethod") continue;
+          this.checkLVal(prop, bindingType, checkClashes, "object destructuring pattern", disallowLetBinding);
+        }
+
+        break;
+
+      case "ArrayPattern":
+        for (let _i3 = 0, _expr$elements = expr.elements; _i3 < _expr$elements.length; _i3++) {
+          const elem = _expr$elements[_i3];
+
+          if (elem) {
+            this.checkLVal(elem, bindingType, checkClashes, "array destructuring pattern", disallowLetBinding);
+          }
+        }
+
+        break;
+
+      case "AssignmentPattern":
+        this.checkLVal(expr.left, bindingType, checkClashes, "assignment pattern");
+        break;
+
+      case "RestElement":
+        this.checkLVal(expr.argument, bindingType, checkClashes, "rest element");
+        break;
+
+      case "ParenthesizedExpression":
+        this.checkLVal(expr.expression, bindingType, checkClashes, "parenthesized expression");
+        break;
+
+      default:
+        {
+          const message = (bindingType === _scopeflags.BIND_NONE ? "Invalid" : "Binding invalid") + " left-hand side" + (contextDescription ? " in " + contextDescription : "expression");
+          this.raise(expr.start, message);
+        }
+    }
+  }
+
+  checkToRestConversion(node) {
+    if (node.argument.type !== "Identifier" && node.argument.type !== "MemberExpression") {
+      this.raise(node.argument.start, "Invalid rest operator's argument");
+    }
+  }
+
+  checkCommaAfterRest(close) {
+    if (this.match(_types.types.comma)) {
+      if (this.lookaheadCharCode() === close) {
+        this.raiseTrailingCommaAfterRest(this.state.start);
+      } else {
+        this.raiseRestNotLast(this.state.start);
+      }
+    }
+  }
+
+  raiseRestNotLast(pos) {
+    throw this.raise(pos, `Rest element must be last element`);
+  }
+
+  raiseTrailingCommaAfterRest(pos) {
+    this.raise(pos, `Unexpected trailing comma after rest element`);
+  }
+
+}
+
+exports.default = LValParser;

Nodejs/node_modules/@babel/parser/lib/parser/node.js

@@ -0,0 +1,89 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.NodeUtils = void 0;
+
+var _util = _interopRequireDefault(require("./util"));
+
+var _location = require("../util/location");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class Node {
+  constructor(parser, pos, loc) {
+    this.type = "";
+    this.start = pos;
+    this.end = 0;
+    this.loc = new _location.SourceLocation(loc);
+    if (parser && parser.options.ranges) this.range = [pos, 0];
+    if (parser && parser.filename) this.loc.filename = parser.filename;
+  }
+
+  __clone() {
+    const newNode = new Node();
+    const keys = Object.keys(this);
+
+    for (let i = 0, length = keys.length; i < length; i++) {
+      const key = keys[i];
+
+      if (key !== "leadingComments" && key !== "trailingComments" && key !== "innerComments") {
+        newNode[key] = this[key];
+      }
+    }
+
+    return newNode;
+  }
+
+}
+
+class NodeUtils extends _util.default {
+  startNode() {
+    return new Node(this, this.state.start, this.state.startLoc);
+  }
+
+  startNodeAt(pos, loc) {
+    return new Node(this, pos, loc);
+  }
+
+  startNodeAtNode(type) {
+    return this.startNodeAt(type.start, type.loc.start);
+  }
+
+  finishNode(node, type) {
+    return this.finishNodeAt(node, type, this.state.lastTokEnd, this.state.lastTokEndLoc);
+  }
+
+  finishNodeAt(node, type, pos, loc) {
+    if (process.env.NODE_ENV !== "production" && node.end > 0) {
+      throw new Error("Do not call finishNode*() twice on the same node." + " Instead use resetEndLocation() or change type directly.");
+    }
+
+    node.type = type;
+    node.end = pos;
+    node.loc.end = loc;
+    if (this.options.ranges) node.range[1] = pos;
+    this.processComment(node);
+    return node;
+  }
+
+  resetStartLocation(node, start, startLoc) {
+    node.start = start;
+    node.loc.start = startLoc;
+    if (this.options.ranges) node.range[0] = start;
+  }
+
+  resetEndLocation(node, end = this.state.lastTokEnd, endLoc = this.state.lastTokEndLoc) {
+    node.end = end;
+    node.loc.end = endLoc;
+    if (this.options.ranges) node.range[1] = end;
+  }
+
+  resetStartLocationFromNode(node, locationNode) {
+    this.resetStartLocation(node, locationNode.start, locationNode.loc.start);
+  }
+
+}
+
+exports.NodeUtils = NodeUtils;

Nodejs/node_modules/@babel/parser/lib/parser/util.js

@@ -0,0 +1,246 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ExpressionErrors = exports.default = void 0;
+
+var _types = require("../tokenizer/types");
+
+var _tokenizer = _interopRequireDefault(require("../tokenizer"));
+
+var _state = _interopRequireDefault(require("../tokenizer/state"));
+
+var _whitespace = require("../util/whitespace");
+
+var _identifier = require("../util/identifier");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const literal = /^('|")((?:\\?.)*?)\1/;
+
+class UtilParser extends _tokenizer.default {
+  addExtra(node, key, val) {
+    if (!node) return;
+    const extra = node.extra = node.extra || {};
+    extra[key] = val;
+  }
+
+  isRelational(op) {
+    return this.match(_types.types.relational) && this.state.value === op;
+  }
+
+  isLookaheadRelational(op) {
+    const next = this.nextTokenStart();
+
+    if (this.input.charAt(next) === op) {
+      if (next + 1 === this.input.length) {
+        return true;
+      }
+
+      const afterNext = this.input.charCodeAt(next + 1);
+      return afterNext !== op.charCodeAt(0) && afterNext !== 61;
+    }
+
+    return false;
+  }
+
+  expectRelational(op) {
+    if (this.isRelational(op)) {
+      this.next();
+    } else {
+      this.unexpected(null, _types.types.relational);
+    }
+  }
+
+  isContextual(name) {
+    return this.match(_types.types.name) && this.state.value === name && !this.state.containsEsc;
+  }
+
+  isUnparsedContextual(nameStart, name) {
+    const nameEnd = nameStart + name.length;
+    return this.input.slice(nameStart, nameEnd) === name && (nameEnd === this.input.length || !(0, _identifier.isIdentifierChar)(this.input.charCodeAt(nameEnd)));
+  }
+
+  isLookaheadContextual(name) {
+    const next = this.nextTokenStart();
+    return this.isUnparsedContextual(next, name);
+  }
+
+  eatContextual(name) {
+    return this.isContextual(name) && this.eat(_types.types.name);
+  }
+
+  expectContextual(name, message) {
+    if (!this.eatContextual(name)) this.unexpected(null, message);
+  }
+
+  canInsertSemicolon() {
+    return this.match(_types.types.eof) || this.match(_types.types.braceR) || this.hasPrecedingLineBreak();
+  }
+
+  hasPrecedingLineBreak() {
+    return _whitespace.lineBreak.test(this.input.slice(this.state.lastTokEnd, this.state.start));
+  }
+
+  isLineTerminator() {
+    return this.eat(_types.types.semi) || this.canInsertSemicolon();
+  }
+
+  semicolon() {
+    if (!this.isLineTerminator()) this.unexpected(null, _types.types.semi);
+  }
+
+  expect(type, pos) {
+    this.eat(type) || this.unexpected(pos, type);
+  }
+
+  assertNoSpace(message = "Unexpected space.") {
+    if (this.state.start > this.state.lastTokEnd) {
+      this.raise(this.state.lastTokEnd, message);
+    }
+  }
+
+  unexpected(pos, messageOrType = "Unexpected token") {
+    if (typeof messageOrType !== "string") {
+      messageOrType = `Unexpected token, expected "${messageOrType.label}"`;
+    }
+
+    throw this.raise(pos != null ? pos : this.state.start, messageOrType);
+  }
+
+  expectPlugin(name, pos) {
+    if (!this.hasPlugin(name)) {
+      throw this.raise(pos != null ? pos : this.state.start, `This experimental syntax requires enabling the parser plugin: '${name}'`, {
+        missingPluginNames: [name]
+      });
+    }
+
+    return true;
+  }
+
+  expectOnePlugin(names, pos) {
+    if (!names.some(n => this.hasPlugin(n))) {
+      throw this.raise(pos != null ? pos : this.state.start, `This experimental syntax requires enabling one of the following parser plugin(s): '${names.join(", ")}'`, {
+        missingPluginNames: names
+      });
+    }
+  }
+
+  checkYieldAwaitInDefaultParams() {
+    if (this.state.yieldPos !== -1 && (this.state.awaitPos === -1 || this.state.yieldPos < this.state.awaitPos)) {
+      this.raise(this.state.yieldPos, "Yield cannot be used as name inside a generator function");
+    }
+
+    if (this.state.awaitPos !== -1) {
+      this.raise(this.state.awaitPos, "Await cannot be used as name inside an async function");
+    }
+  }
+
+  strictDirective(start) {
+    for (;;) {
+      _whitespace.skipWhiteSpace.lastIndex = start;
+      start += _whitespace.skipWhiteSpace.exec(this.input)[0].length;
+      const match = literal.exec(this.input.slice(start));
+      if (!match) break;
+      if (match[2] === "use strict") return true;
+      start += match[0].length;
+      _whitespace.skipWhiteSpace.lastIndex = start;
+      start += _whitespace.skipWhiteSpace.exec(this.input)[0].length;
+
+      if (this.input[start] === ";") {
+        start++;
+      }
+    }
+
+    return false;
+  }
+
+  tryParse(fn, oldState = this.state.clone()) {
+    const abortSignal = {
+      node: null
+    };
+
+    try {
+      const node = fn((node = null) => {
+        abortSignal.node = node;
+        throw abortSignal;
+      });
+
+      if (this.state.errors.length > oldState.errors.length) {
+        const failState = this.state;
+        this.state = oldState;
+        return {
+          node,
+          error: failState.errors[oldState.errors.length],
+          thrown: false,
+          aborted: false,
+          failState
+        };
+      }
+
+      return {
+        node,
+        error: null,
+        thrown: false,
+        aborted: false,
+        failState: null
+      };
+    } catch (error) {
+      const failState = this.state;
+      this.state = oldState;
+
+      if (error instanceof SyntaxError) {
+        return {
+          node: null,
+          error,
+          thrown: true,
+          aborted: false,
+          failState
+        };
+      }
+
+      if (error === abortSignal) {
+        return {
+          node: abortSignal.node,
+          error: null,
+          thrown: false,
+          aborted: true,
+          failState
+        };
+      }
+
+      throw error;
+    }
+  }
+
+  checkExpressionErrors(refExpressionErrors, andThrow) {
+    if (!refExpressionErrors) return false;
+    const {
+      shorthandAssign,
+      doubleProto
+    } = refExpressionErrors;
+    if (!andThrow) return shorthandAssign >= 0 || doubleProto >= 0;
+
+    if (shorthandAssign >= 0) {
+      this.unexpected(shorthandAssign);
+    }
+
+    if (doubleProto >= 0) {
+      this.raise(doubleProto, "Redefinition of __proto__ property");
+    }
+  }
+
+}
+
+exports.default = UtilParser;
+
+class ExpressionErrors {
+  constructor() {
+    this.shorthandAssign = -1;
+    this.doubleProto = -1;
+  }
+
+}
+
+exports.ExpressionErrors = ExpressionErrors;

Nodejs/node_modules/@babel/parser/lib/plugin-utils.js

@@ -0,0 +1,91 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.hasPlugin = hasPlugin;
+exports.getPluginOption = getPluginOption;
+exports.validatePlugins = validatePlugins;
+exports.mixinPluginNames = exports.mixinPlugins = void 0;
+
+var _estree = _interopRequireDefault(require("./plugins/estree"));
+
+var _flow = _interopRequireDefault(require("./plugins/flow"));
+
+var _jsx = _interopRequireDefault(require("./plugins/jsx"));
+
+var _typescript = _interopRequireDefault(require("./plugins/typescript"));
+
+var _placeholders = _interopRequireDefault(require("./plugins/placeholders"));
+
+var _v8intrinsic = _interopRequireDefault(require("./plugins/v8intrinsic"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function hasPlugin(plugins, name) {
+  return plugins.some(plugin => {
+    if (Array.isArray(plugin)) {
+      return plugin[0] === name;
+    } else {
+      return plugin === name;
+    }
+  });
+}
+
+function getPluginOption(plugins, name, option) {
+  const plugin = plugins.find(plugin => {
+    if (Array.isArray(plugin)) {
+      return plugin[0] === name;
+    } else {
+      return plugin === name;
+    }
+  });
+
+  if (plugin && Array.isArray(plugin)) {
+    return plugin[1][option];
+  }
+
+  return null;
+}
+
+const PIPELINE_PROPOSALS = ["minimal", "smart", "fsharp"];
+
+function validatePlugins(plugins) {
+  if (hasPlugin(plugins, "decorators")) {
+    if (hasPlugin(plugins, "decorators-legacy")) {
+      throw new Error("Cannot use the decorators and decorators-legacy plugin together");
+    }
+
+    const decoratorsBeforeExport = getPluginOption(plugins, "decorators", "decoratorsBeforeExport");
+
+    if (decoratorsBeforeExport == null) {
+      throw new Error("The 'decorators' plugin requires a 'decoratorsBeforeExport' option," + " whose value must be a boolean. If you are migrating from" + " Babylon/Babel 6 or want to use the old decorators proposal, you" + " should use the 'decorators-legacy' plugin instead of 'decorators'.");
+    } else if (typeof decoratorsBeforeExport !== "boolean") {
+      throw new Error("'decoratorsBeforeExport' must be a boolean.");
+    }
+  }
+
+  if (hasPlugin(plugins, "flow") && hasPlugin(plugins, "typescript")) {
+    throw new Error("Cannot combine flow and typescript plugins.");
+  }
+
+  if (hasPlugin(plugins, "placeholders") && hasPlugin(plugins, "v8intrinsic")) {
+    throw new Error("Cannot combine placeholders and v8intrinsic plugins.");
+  }
+
+  if (hasPlugin(plugins, "pipelineOperator") && !PIPELINE_PROPOSALS.includes(getPluginOption(plugins, "pipelineOperator", "proposal"))) {
+    throw new Error("'pipelineOperator' requires 'proposal' option whose value should be one of: " + PIPELINE_PROPOSALS.map(p => `'${p}'`).join(", "));
+  }
+}
+
+const mixinPlugins = {
+  estree: _estree.default,
+  jsx: _jsx.default,
+  flow: _flow.default,
+  typescript: _typescript.default,
+  v8intrinsic: _v8intrinsic.default,
+  placeholders: _placeholders.default
+};
+exports.mixinPlugins = mixinPlugins;
+const mixinPluginNames = Object.keys(mixinPlugins);
+exports.mixinPluginNames = mixinPluginNames;

Nodejs/node_modules/@babel/parser/lib/plugins/estree.js

@@ -0,0 +1,269 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _types = require("../tokenizer/types");
+
+var N = _interopRequireWildcard(require("../types"));
+
+var _scopeflags = require("../util/scopeflags");
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function isSimpleProperty(node) {
+  return node != null && node.type === "Property" && node.kind === "init" && node.method === false;
+}
+
+var _default = superClass => class extends superClass {
+  estreeParseRegExpLiteral({
+    pattern,
+    flags
+  }) {
+    let regex = null;
+
+    try {
+      regex = new RegExp(pattern, flags);
+    } catch (e) {}
+
+    const node = this.estreeParseLiteral(regex);
+    node.regex = {
+      pattern,
+      flags
+    };
+    return node;
+  }
+
+  estreeParseBigIntLiteral(value) {
+    const bigInt = typeof BigInt !== "undefined" ? BigInt(value) : null;
+    const node = this.estreeParseLiteral(bigInt);
+    node.bigint = String(node.value || value);
+    return node;
+  }
+
+  estreeParseLiteral(value) {
+    return this.parseLiteral(value, "Literal");
+  }
+
+  directiveToStmt(directive) {
+    const directiveLiteral = directive.value;
+    const stmt = this.startNodeAt(directive.start, directive.loc.start);
+    const expression = this.startNodeAt(directiveLiteral.start, directiveLiteral.loc.start);
+    expression.value = directiveLiteral.value;
+    expression.raw = directiveLiteral.extra.raw;
+    stmt.expression = this.finishNodeAt(expression, "Literal", directiveLiteral.end, directiveLiteral.loc.end);
+    stmt.directive = directiveLiteral.extra.raw.slice(1, -1);
+    return this.finishNodeAt(stmt, "ExpressionStatement", directive.end, directive.loc.end);
+  }
+
+  initFunction(node, isAsync) {
+    super.initFunction(node, isAsync);
+    node.expression = false;
+  }
+
+  checkDeclaration(node) {
+    if (isSimpleProperty(node)) {
+      this.checkDeclaration(node.value);
+    } else {
+      super.checkDeclaration(node);
+    }
+  }
+
+  checkGetterSetterParams(method) {
+    const prop = method;
+    const paramCount = prop.kind === "get" ? 0 : 1;
+    const start = prop.start;
+
+    if (prop.value.params.length !== paramCount) {
+      if (prop.kind === "get") {
+        this.raise(start, "getter must not have any formal parameters");
+      } else {
+        this.raise(start, "setter must have exactly one formal parameter");
+      }
+    } else if (prop.kind === "set" && prop.value.params[0].type === "RestElement") {
+      this.raise(start, "setter function argument must not be a rest parameter");
+    }
+  }
+
+  checkLVal(expr, bindingType = _scopeflags.BIND_NONE, checkClashes, contextDescription, disallowLetBinding) {
+    switch (expr.type) {
+      case "ObjectPattern":
+        expr.properties.forEach(prop => {
+          this.checkLVal(prop.type === "Property" ? prop.value : prop, bindingType, checkClashes, "object destructuring pattern", disallowLetBinding);
+        });
+        break;
+
+      default:
+        super.checkLVal(expr, bindingType, checkClashes, contextDescription, disallowLetBinding);
+    }
+  }
+
+  checkDuplicatedProto(prop, protoRef, refExpressionErrors) {
+    if (prop.type === "SpreadElement" || prop.computed || prop.method || prop.shorthand) {
+      return;
+    }
+
+    const key = prop.key;
+    const name = key.type === "Identifier" ? key.name : String(key.value);
+
+    if (name === "__proto__" && prop.kind === "init") {
+      if (protoRef.used) {
+        if (refExpressionErrors && refExpressionErrors.doubleProto === -1) {
+          refExpressionErrors.doubleProto = key.start;
+        } else {
+          this.raise(key.start, "Redefinition of __proto__ property");
+        }
+      }
+
+      protoRef.used = true;
+    }
+  }
+
+  isValidDirective(stmt) {
+    return stmt.type === "ExpressionStatement" && stmt.expression.type === "Literal" && typeof stmt.expression.value === "string" && (!stmt.expression.extra || !stmt.expression.extra.parenthesized);
+  }
+
+  stmtToDirective(stmt) {
+    const directive = super.stmtToDirective(stmt);
+    const value = stmt.expression.value;
+    directive.value.value = value;
+    return directive;
+  }
+
+  parseBlockBody(node, allowDirectives, topLevel, end) {
+    super.parseBlockBody(node, allowDirectives, topLevel, end);
+    const directiveStatements = node.directives.map(d => this.directiveToStmt(d));
+    node.body = directiveStatements.concat(node.body);
+    delete node.directives;
+  }
+
+  pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) {
+    this.parseMethod(method, isGenerator, isAsync, isConstructor, allowsDirectSuper, "ClassMethod", true);
+
+    if (method.typeParameters) {
+      method.value.typeParameters = method.typeParameters;
+      delete method.typeParameters;
+    }
+
+    classBody.body.push(method);
+  }
+
+  parseExprAtom(refExpressionErrors) {
+    switch (this.state.type) {
+      case _types.types.num:
+      case _types.types.string:
+        return this.estreeParseLiteral(this.state.value);
+
+      case _types.types.regexp:
+        return this.estreeParseRegExpLiteral(this.state.value);
+
+      case _types.types.bigint:
+        return this.estreeParseBigIntLiteral(this.state.value);
+
+      case _types.types._null:
+        return this.estreeParseLiteral(null);
+
+      case _types.types._true:
+        return this.estreeParseLiteral(true);
+
+      case _types.types._false:
+        return this.estreeParseLiteral(false);
+
+      default:
+        return super.parseExprAtom(refExpressionErrors);
+    }
+  }
+
+  parseLiteral(value, type, startPos, startLoc) {
+    const node = super.parseLiteral(value, type, startPos, startLoc);
+    node.raw = node.extra.raw;
+    delete node.extra;
+    return node;
+  }
+
+  parseFunctionBody(node, allowExpression, isMethod = false) {
+    super.parseFunctionBody(node, allowExpression, isMethod);
+    node.expression = node.body.type !== "BlockStatement";
+  }
+
+  parseMethod(node, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope = false) {
+    let funcNode = this.startNode();
+    funcNode.kind = node.kind;
+    funcNode = super.parseMethod(funcNode, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope);
+    funcNode.type = "FunctionExpression";
+    delete funcNode.kind;
+    node.value = funcNode;
+    type = type === "ClassMethod" ? "MethodDefinition" : type;
+    return this.finishNode(node, type);
+  }
+
+  parseObjectMethod(prop, isGenerator, isAsync, isPattern, containsEsc) {
+    const node = super.parseObjectMethod(prop, isGenerator, isAsync, isPattern, containsEsc);
+
+    if (node) {
+      node.type = "Property";
+      if (node.kind === "method") node.kind = "init";
+      node.shorthand = false;
+    }
+
+    return node;
+  }
+
+  parseObjectProperty(prop, startPos, startLoc, isPattern, refExpressionErrors) {
+    const node = super.parseObjectProperty(prop, startPos, startLoc, isPattern, refExpressionErrors);
+
+    if (node) {
+      node.kind = "init";
+      node.type = "Property";
+    }
+
+    return node;
+  }
+
+  toAssignable(node) {
+    if (isSimpleProperty(node)) {
+      this.toAssignable(node.value);
+      return node;
+    }
+
+    return super.toAssignable(node);
+  }
+
+  toAssignableObjectExpressionProp(prop, isLast) {
+    if (prop.kind === "get" || prop.kind === "set") {
+      throw this.raise(prop.key.start, "Object pattern can't contain getter or setter");
+    } else if (prop.method) {
+      throw this.raise(prop.key.start, "Object pattern can't contain methods");
+    } else {
+      super.toAssignableObjectExpressionProp(prop, isLast);
+    }
+  }
+
+  finishCallExpression(node, optional) {
+    super.finishCallExpression(node, optional);
+
+    if (node.callee.type === "Import") {
+      node.type = "ImportExpression";
+      node.source = node.arguments[0];
+      delete node.arguments;
+      delete node.callee;
+    }
+
+    return node;
+  }
+
+  toReferencedListDeep(exprList, isParenthesizedExpr) {
+    if (!exprList) {
+      return;
+    }
+
+    super.toReferencedListDeep(exprList, isParenthesizedExpr);
+  }
+
+};
+
+exports.default = _default;

Nodejs/node_modules/@babel/parser/lib/plugins/jsx/index.js

@@ -0,0 +1,516 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _xhtml = _interopRequireDefault(require("./xhtml"));
+
+var _types = require("../../tokenizer/types");
+
+var _context = require("../../tokenizer/context");
+
+var N = _interopRequireWildcard(require("../../types"));
+
+var _identifier = require("../../util/identifier");
+
+var _whitespace = require("../../util/whitespace");
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const HEX_NUMBER = /^[\da-fA-F]+$/;
+const DECIMAL_NUMBER = /^\d+$/;
+_context.types.j_oTag = new _context.TokContext("<tag", false);
+_context.types.j_cTag = new _context.TokContext("</tag", false);
+_context.types.j_expr = new _context.TokContext("<tag>...</tag>", true, true);
+_types.types.jsxName = new _types.TokenType("jsxName");
+_types.types.jsxText = new _types.TokenType("jsxText", {
+  beforeExpr: true
+});
+_types.types.jsxTagStart = new _types.TokenType("jsxTagStart", {
+  startsExpr: true
+});
+_types.types.jsxTagEnd = new _types.TokenType("jsxTagEnd");
+
+_types.types.jsxTagStart.updateContext = function () {
+  this.state.context.push(_context.types.j_expr);
+  this.state.context.push(_context.types.j_oTag);
+  this.state.exprAllowed = false;
+};
+
+_types.types.jsxTagEnd.updateContext = function (prevType) {
+  const out = this.state.context.pop();
+
+  if (out === _context.types.j_oTag && prevType === _types.types.slash || out === _context.types.j_cTag) {
+    this.state.context.pop();
+    this.state.exprAllowed = this.curContext() === _context.types.j_expr;
+  } else {
+    this.state.exprAllowed = true;
+  }
+};
+
+function isFragment(object) {
+  return object ? object.type === "JSXOpeningFragment" || object.type === "JSXClosingFragment" : false;
+}
+
+function getQualifiedJSXName(object) {
+  if (object.type === "JSXIdentifier") {
+    return object.name;
+  }
+
+  if (object.type === "JSXNamespacedName") {
+    return object.namespace.name + ":" + object.name.name;
+  }
+
+  if (object.type === "JSXMemberExpression") {
+    return getQualifiedJSXName(object.object) + "." + getQualifiedJSXName(object.property);
+  }
+
+  throw new Error("Node had unexpected type: " + object.type);
+}
+
+var _default = superClass => class extends superClass {
+  jsxReadToken() {
+    let out = "";
+    let chunkStart = this.state.pos;
+
+    for (;;) {
+      if (this.state.pos >= this.length) {
+        throw this.raise(this.state.start, "Unterminated JSX contents");
+      }
+
+      const ch = this.input.charCodeAt(this.state.pos);
+
+      switch (ch) {
+        case 60:
+        case 123:
+          if (this.state.pos === this.state.start) {
+            if (ch === 60 && this.state.exprAllowed) {
+              ++this.state.pos;
+              return this.finishToken(_types.types.jsxTagStart);
+            }
+
+            return super.getTokenFromCode(ch);
+          }
+
+          out += this.input.slice(chunkStart, this.state.pos);
+          return this.finishToken(_types.types.jsxText, out);
+
+        case 38:
+          out += this.input.slice(chunkStart, this.state.pos);
+          out += this.jsxReadEntity();
+          chunkStart = this.state.pos;
+          break;
+
+        default:
+          if ((0, _whitespace.isNewLine)(ch)) {
+            out += this.input.slice(chunkStart, this.state.pos);
+            out += this.jsxReadNewLine(true);
+            chunkStart = this.state.pos;
+          } else {
+            ++this.state.pos;
+          }
+
+      }
+    }
+  }
+
+  jsxReadNewLine(normalizeCRLF) {
+    const ch = this.input.charCodeAt(this.state.pos);
+    let out;
+    ++this.state.pos;
+
+    if (ch === 13 && this.input.charCodeAt(this.state.pos) === 10) {
+      ++this.state.pos;
+      out = normalizeCRLF ? "\n" : "\r\n";
+    } else {
+      out = String.fromCharCode(ch);
+    }
+
+    ++this.state.curLine;
+    this.state.lineStart = this.state.pos;
+    return out;
+  }
+
+  jsxReadString(quote) {
+    let out = "";
+    let chunkStart = ++this.state.pos;
+
+    for (;;) {
+      if (this.state.pos >= this.length) {
+        throw this.raise(this.state.start, "Unterminated string constant");
+      }
+
+      const ch = this.input.charCodeAt(this.state.pos);
+      if (ch === quote) break;
+
+      if (ch === 38) {
+        out += this.input.slice(chunkStart, this.state.pos);
+        out += this.jsxReadEntity();
+        chunkStart = this.state.pos;
+      } else if ((0, _whitespace.isNewLine)(ch)) {
+        out += this.input.slice(chunkStart, this.state.pos);
+        out += this.jsxReadNewLine(false);
+        chunkStart = this.state.pos;
+      } else {
+        ++this.state.pos;
+      }
+    }
+
+    out += this.input.slice(chunkStart, this.state.pos++);
+    return this.finishToken(_types.types.string, out);
+  }
+
+  jsxReadEntity() {
+    let str = "";
+    let count = 0;
+    let entity;
+    let ch = this.input[this.state.pos];
+    const startPos = ++this.state.pos;
+
+    while (this.state.pos < this.length && count++ < 10) {
+      ch = this.input[this.state.pos++];
+
+      if (ch === ";") {
+        if (str[0] === "#") {
+          if (str[1] === "x") {
+            str = str.substr(2);
+
+            if (HEX_NUMBER.test(str)) {
+              entity = String.fromCodePoint(parseInt(str, 16));
+            }
+          } else {
+            str = str.substr(1);
+
+            if (DECIMAL_NUMBER.test(str)) {
+              entity = String.fromCodePoint(parseInt(str, 10));
+            }
+          }
+        } else {
+          entity = _xhtml.default[str];
+        }
+
+        break;
+      }
+
+      str += ch;
+    }
+
+    if (!entity) {
+      this.state.pos = startPos;
+      return "&";
+    }
+
+    return entity;
+  }
+
+  jsxReadWord() {
+    let ch;
+    const start = this.state.pos;
+
+    do {
+      ch = this.input.charCodeAt(++this.state.pos);
+    } while ((0, _identifier.isIdentifierChar)(ch) || ch === 45);
+
+    return this.finishToken(_types.types.jsxName, this.input.slice(start, this.state.pos));
+  }
+
+  jsxParseIdentifier() {
+    const node = this.startNode();
+
+    if (this.match(_types.types.jsxName)) {
+      node.name = this.state.value;
+    } else if (this.state.type.keyword) {
+      node.name = this.state.type.keyword;
+    } else {
+      this.unexpected();
+    }
+
+    this.next();
+    return this.finishNode(node, "JSXIdentifier");
+  }
+
+  jsxParseNamespacedName() {
+    const startPos = this.state.start;
+    const startLoc = this.state.startLoc;
+    const name = this.jsxParseIdentifier();
+    if (!this.eat(_types.types.colon)) return name;
+    const node = this.startNodeAt(startPos, startLoc);
+    node.namespace = name;
+    node.name = this.jsxParseIdentifier();
+    return this.finishNode(node, "JSXNamespacedName");
+  }
+
+  jsxParseElementName() {
+    const startPos = this.state.start;
+    const startLoc = this.state.startLoc;
+    let node = this.jsxParseNamespacedName();
+
+    if (node.type === "JSXNamespacedName") {
+      return node;
+    }
+
+    while (this.eat(_types.types.dot)) {
+      const newNode = this.startNodeAt(startPos, startLoc);
+      newNode.object = node;
+      newNode.property = this.jsxParseIdentifier();
+      node = this.finishNode(newNode, "JSXMemberExpression");
+    }
+
+    return node;
+  }
+
+  jsxParseAttributeValue() {
+    let node;
+
+    switch (this.state.type) {
+      case _types.types.braceL:
+        node = this.startNode();
+        this.next();
+        node = this.jsxParseExpressionContainer(node);
+
+        if (node.expression.type === "JSXEmptyExpression") {
+          this.raise(node.start, "JSX attributes must only be assigned a non-empty expression");
+        }
+
+        return node;
+
+      case _types.types.jsxTagStart:
+      case _types.types.string:
+        return this.parseExprAtom();
+
+      default:
+        throw this.raise(this.state.start, "JSX value should be either an expression or a quoted JSX text");
+    }
+  }
+
+  jsxParseEmptyExpression() {
+    const node = this.startNodeAt(this.state.lastTokEnd, this.state.lastTokEndLoc);
+    return this.finishNodeAt(node, "JSXEmptyExpression", this.state.start, this.state.startLoc);
+  }
+
+  jsxParseSpreadChild(node) {
+    this.next();
+    node.expression = this.parseExpression();
+    this.expect(_types.types.braceR);
+    return this.finishNode(node, "JSXSpreadChild");
+  }
+
+  jsxParseExpressionContainer(node) {
+    if (this.match(_types.types.braceR)) {
+      node.expression = this.jsxParseEmptyExpression();
+    } else {
+      node.expression = this.parseExpression();
+    }
+
+    this.expect(_types.types.braceR);
+    return this.finishNode(node, "JSXExpressionContainer");
+  }
+
+  jsxParseAttribute() {
+    const node = this.startNode();
+
+    if (this.eat(_types.types.braceL)) {
+      this.expect(_types.types.ellipsis);
+      node.argument = this.parseMaybeAssign();
+      this.expect(_types.types.braceR);
+      return this.finishNode(node, "JSXSpreadAttribute");
+    }
+
+    node.name = this.jsxParseNamespacedName();
+    node.value = this.eat(_types.types.eq) ? this.jsxParseAttributeValue() : null;
+    return this.finishNode(node, "JSXAttribute");
+  }
+
+  jsxParseOpeningElementAt(startPos, startLoc) {
+    const node = this.startNodeAt(startPos, startLoc);
+
+    if (this.match(_types.types.jsxTagEnd)) {
+      this.expect(_types.types.jsxTagEnd);
+      return this.finishNode(node, "JSXOpeningFragment");
+    }
+
+    node.name = this.jsxParseElementName();
+    return this.jsxParseOpeningElementAfterName(node);
+  }
+
+  jsxParseOpeningElementAfterName(node) {
+    const attributes = [];
+
+    while (!this.match(_types.types.slash) && !this.match(_types.types.jsxTagEnd)) {
+      attributes.push(this.jsxParseAttribute());
+    }
+
+    node.attributes = attributes;
+    node.selfClosing = this.eat(_types.types.slash);
+    this.expect(_types.types.jsxTagEnd);
+    return this.finishNode(node, "JSXOpeningElement");
+  }
+
+  jsxParseClosingElementAt(startPos, startLoc) {
+    const node = this.startNodeAt(startPos, startLoc);
+
+    if (this.match(_types.types.jsxTagEnd)) {
+      this.expect(_types.types.jsxTagEnd);
+      return this.finishNode(node, "JSXClosingFragment");
+    }
+
+    node.name = this.jsxParseElementName();
+    this.expect(_types.types.jsxTagEnd);
+    return this.finishNode(node, "JSXClosingElement");
+  }
+
+  jsxParseElementAt(startPos, startLoc) {
+    const node = this.startNodeAt(startPos, startLoc);
+    const children = [];
+    const openingElement = this.jsxParseOpeningElementAt(startPos, startLoc);
+    let closingElement = null;
+
+    if (!openingElement.selfClosing) {
+      contents: for (;;) {
+        switch (this.state.type) {
+          case _types.types.jsxTagStart:
+            startPos = this.state.start;
+            startLoc = this.state.startLoc;
+            this.next();
+
+            if (this.eat(_types.types.slash)) {
+              closingElement = this.jsxParseClosingElementAt(startPos, startLoc);
+              break contents;
+            }
+
+            children.push(this.jsxParseElementAt(startPos, startLoc));
+            break;
+
+          case _types.types.jsxText:
+            children.push(this.parseExprAtom());
+            break;
+
+          case _types.types.braceL:
+            {
+              const node = this.startNode();
+              this.next();
+
+              if (this.match(_types.types.ellipsis)) {
+                children.push(this.jsxParseSpreadChild(node));
+              } else {
+                children.push(this.jsxParseExpressionContainer(node));
+              }
+
+              break;
+            }
+
+          default:
+            throw this.unexpected();
+        }
+      }
+
+      if (isFragment(openingElement) && !isFragment(closingElement)) {
+        this.raise(closingElement.start, "Expected corresponding JSX closing tag for <>");
+      } else if (!isFragment(openingElement) && isFragment(closingElement)) {
+        this.raise(closingElement.start, "Expected corresponding JSX closing tag for <" + getQualifiedJSXName(openingElement.name) + ">");
+      } else if (!isFragment(openingElement) && !isFragment(closingElement)) {
+        if (getQualifiedJSXName(closingElement.name) !== getQualifiedJSXName(openingElement.name)) {
+          this.raise(closingElement.start, "Expected corresponding JSX closing tag for <" + getQualifiedJSXName(openingElement.name) + ">");
+        }
+      }
+    }
+
+    if (isFragment(openingElement)) {
+      node.openingFragment = openingElement;
+      node.closingFragment = closingElement;
+    } else {
+      node.openingElement = openingElement;
+      node.closingElement = closingElement;
+    }
+
+    node.children = children;
+
+    if (this.isRelational("<")) {
+      throw this.raise(this.state.start, "Adjacent JSX elements must be wrapped in an enclosing tag. " + "Did you want a JSX fragment <>...</>?");
+    }
+
+    return isFragment(openingElement) ? this.finishNode(node, "JSXFragment") : this.finishNode(node, "JSXElement");
+  }
+
+  jsxParseElement() {
+    const startPos = this.state.start;
+    const startLoc = this.state.startLoc;
+    this.next();
+    return this.jsxParseElementAt(startPos, startLoc);
+  }
+
+  parseExprAtom(refExpressionErrors) {
+    if (this.match(_types.types.jsxText)) {
+      return this.parseLiteral(this.state.value, "JSXText");
+    } else if (this.match(_types.types.jsxTagStart)) {
+      return this.jsxParseElement();
+    } else if (this.isRelational("<") && this.input.charCodeAt(this.state.pos) !== 33) {
+      this.finishToken(_types.types.jsxTagStart);
+      return this.jsxParseElement();
+    } else {
+      return super.parseExprAtom(refExpressionErrors);
+    }
+  }
+
+  getTokenFromCode(code) {
+    if (this.state.inPropertyName) return super.getTokenFromCode(code);
+    const context = this.curContext();
+
+    if (context === _context.types.j_expr) {
+      return this.jsxReadToken();
+    }
+
+    if (context === _context.types.j_oTag || context === _context.types.j_cTag) {
+      if ((0, _identifier.isIdentifierStart)(code)) {
+        return this.jsxReadWord();
+      }
+
+      if (code === 62) {
+        ++this.state.pos;
+        return this.finishToken(_types.types.jsxTagEnd);
+      }
+
+      if ((code === 34 || code === 39) && context === _context.types.j_oTag) {
+        return this.jsxReadString(code);
+      }
+    }
+
+    if (code === 60 && this.state.exprAllowed && this.input.charCodeAt(this.state.pos + 1) !== 33) {
+      ++this.state.pos;
+      return this.finishToken(_types.types.jsxTagStart);
+    }
+
+    return super.getTokenFromCode(code);
+  }
+
+  updateContext(prevType) {
+    if (this.match(_types.types.braceL)) {
+      const curContext = this.curContext();
+
+      if (curContext === _context.types.j_oTag) {
+        this.state.context.push(_context.types.braceExpression);
+      } else if (curContext === _context.types.j_expr) {
+        this.state.context.push(_context.types.templateQuasi);
+      } else {
+        super.updateContext(prevType);
+      }
+
+      this.state.exprAllowed = true;
+    } else if (this.match(_types.types.slash) && prevType === _types.types.jsxTagStart) {
+      this.state.context.length -= 2;
+      this.state.context.push(_context.types.j_cTag);
+      this.state.exprAllowed = false;
+    } else {
+      return super.updateContext(prevType);
+    }
+  }
+
+};
+
+exports.default = _default;

Nodejs/node_modules/@babel/parser/lib/plugins/jsx/xhtml.js

@@ -0,0 +1,263 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+const entities = {
+  quot: "\u0022",
+  amp: "&",
+  apos: "\u0027",
+  lt: "<",
+  gt: ">",
+  nbsp: "\u00A0",
+  iexcl: "\u00A1",
+  cent: "\u00A2",
+  pound: "\u00A3",
+  curren: "\u00A4",
+  yen: "\u00A5",
+  brvbar: "\u00A6",
+  sect: "\u00A7",
+  uml: "\u00A8",
+  copy: "\u00A9",
+  ordf: "\u00AA",
+  laquo: "\u00AB",
+  not: "\u00AC",
+  shy: "\u00AD",
+  reg: "\u00AE",
+  macr: "\u00AF",
+  deg: "\u00B0",
+  plusmn: "\u00B1",
+  sup2: "\u00B2",
+  sup3: "\u00B3",
+  acute: "\u00B4",
+  micro: "\u00B5",
+  para: "\u00B6",
+  middot: "\u00B7",
+  cedil: "\u00B8",
+  sup1: "\u00B9",
+  ordm: "\u00BA",
+  raquo: "\u00BB",
+  frac14: "\u00BC",
+  frac12: "\u00BD",
+  frac34: "\u00BE",
+  iquest: "\u00BF",
+  Agrave: "\u00C0",
+  Aacute: "\u00C1",
+  Acirc: "\u00C2",
+  Atilde: "\u00C3",
+  Auml: "\u00C4",
+  Aring: "\u00C5",
+  AElig: "\u00C6",
+  Ccedil: "\u00C7",
+  Egrave: "\u00C8",
+  Eacute: "\u00C9",
+  Ecirc: "\u00CA",
+  Euml: "\u00CB",
+  Igrave: "\u00CC",
+  Iacute: "\u00CD",
+  Icirc: "\u00CE",
+  Iuml: "\u00CF",
+  ETH: "\u00D0",
+  Ntilde: "\u00D1",
+  Ograve: "\u00D2",
+  Oacute: "\u00D3",
+  Ocirc: "\u00D4",
+  Otilde: "\u00D5",
+  Ouml: "\u00D6",
+  times: "\u00D7",
+  Oslash: "\u00D8",
+  Ugrave: "\u00D9",
+  Uacute: "\u00DA",
+  Ucirc: "\u00DB",
+  Uuml: "\u00DC",
+  Yacute: "\u00DD",
+  THORN: "\u00DE",
+  szlig: "\u00DF",
+  agrave: "\u00E0",
+  aacute: "\u00E1",
+  acirc: "\u00E2",
+  atilde: "\u00E3",
+  auml: "\u00E4",
+  aring: "\u00E5",
+  aelig: "\u00E6",
+  ccedil: "\u00E7",
+  egrave: "\u00E8",
+  eacute: "\u00E9",
+  ecirc: "\u00EA",
+  euml: "\u00EB",
+  igrave: "\u00EC",
+  iacute: "\u00ED",
+  icirc: "\u00EE",
+  iuml: "\u00EF",
+  eth: "\u00F0",
+  ntilde: "\u00F1",
+  ograve: "\u00F2",
+  oacute: "\u00F3",
+  ocirc: "\u00F4",
+  otilde: "\u00F5",
+  ouml: "\u00F6",
+  divide: "\u00F7",
+  oslash: "\u00F8",
+  ugrave: "\u00F9",
+  uacute: "\u00FA",
+  ucirc: "\u00FB",
+  uuml: "\u00FC",
+  yacute: "\u00FD",
+  thorn: "\u00FE",
+  yuml: "\u00FF",
+  OElig: "\u0152",
+  oelig: "\u0153",
+  Scaron: "\u0160",
+  scaron: "\u0161",
+  Yuml: "\u0178",
+  fnof: "\u0192",
+  circ: "\u02C6",
+  tilde: "\u02DC",
+  Alpha: "\u0391",
+  Beta: "\u0392",
+  Gamma: "\u0393",
+  Delta: "\u0394",
+  Epsilon: "\u0395",
+  Zeta: "\u0396",
+  Eta: "\u0397",
+  Theta: "\u0398",
+  Iota: "\u0399",
+  Kappa: "\u039A",
+  Lambda: "\u039B",
+  Mu: "\u039C",
+  Nu: "\u039D",
+  Xi: "\u039E",
+  Omicron: "\u039F",
+  Pi: "\u03A0",
+  Rho: "\u03A1",
+  Sigma: "\u03A3",
+  Tau: "\u03A4",
+  Upsilon: "\u03A5",
+  Phi: "\u03A6",
+  Chi: "\u03A7",
+  Psi: "\u03A8",
+  Omega: "\u03A9",
+  alpha: "\u03B1",
+  beta: "\u03B2",
+  gamma: "\u03B3",
+  delta: "\u03B4",
+  epsilon: "\u03B5",
+  zeta: "\u03B6",
+  eta: "\u03B7",
+  theta: "\u03B8",
+  iota: "\u03B9",
+  kappa: "\u03BA",
+  lambda: "\u03BB",
+  mu: "\u03BC",
+  nu: "\u03BD",
+  xi: "\u03BE",
+  omicron: "\u03BF",
+  pi: "\u03C0",
+  rho: "\u03C1",
+  sigmaf: "\u03C2",
+  sigma: "\u03C3",
+  tau: "\u03C4",
+  upsilon: "\u03C5",
+  phi: "\u03C6",
+  chi: "\u03C7",
+  psi: "\u03C8",
+  omega: "\u03C9",
+  thetasym: "\u03D1",
+  upsih: "\u03D2",
+  piv: "\u03D6",
+  ensp: "\u2002",
+  emsp: "\u2003",
+  thinsp: "\u2009",
+  zwnj: "\u200C",
+  zwj: "\u200D",
+  lrm: "\u200E",
+  rlm: "\u200F",
+  ndash: "\u2013",
+  mdash: "\u2014",
+  lsquo: "\u2018",
+  rsquo: "\u2019",
+  sbquo: "\u201A",
+  ldquo: "\u201C",
+  rdquo: "\u201D",
+  bdquo: "\u201E",
+  dagger: "\u2020",
+  Dagger: "\u2021",
+  bull: "\u2022",
+  hellip: "\u2026",
+  permil: "\u2030",
+  prime: "\u2032",
+  Prime: "\u2033",
+  lsaquo: "\u2039",
+  rsaquo: "\u203A",
+  oline: "\u203E",
+  frasl: "\u2044",
+  euro: "\u20AC",
+  image: "\u2111",
+  weierp: "\u2118",
+  real: "\u211C",
+  trade: "\u2122",
+  alefsym: "\u2135",
+  larr: "\u2190",
+  uarr: "\u2191",
+  rarr: "\u2192",
+  darr: "\u2193",
+  harr: "\u2194",
+  crarr: "\u21B5",
+  lArr: "\u21D0",
+  uArr: "\u21D1",
+  rArr: "\u21D2",
+  dArr: "\u21D3",
+  hArr: "\u21D4",
+  forall: "\u2200",
+  part: "\u2202",
+  exist: "\u2203",
+  empty: "\u2205",
+  nabla: "\u2207",
+  isin: "\u2208",
+  notin: "\u2209",
+  ni: "\u220B",
+  prod: "\u220F",
+  sum: "\u2211",
+  minus: "\u2212",
+  lowast: "\u2217",
+  radic: "\u221A",
+  prop: "\u221D",
+  infin: "\u221E",
+  ang: "\u2220",
+  and: "\u2227",
+  or: "\u2228",
+  cap: "\u2229",
+  cup: "\u222A",
+  int: "\u222B",
+  there4: "\u2234",
+  sim: "\u223C",
+  cong: "\u2245",
+  asymp: "\u2248",
+  ne: "\u2260",
+  equiv: "\u2261",
+  le: "\u2264",
+  ge: "\u2265",
+  sub: "\u2282",
+  sup: "\u2283",
+  nsub: "\u2284",
+  sube: "\u2286",
+  supe: "\u2287",
+  oplus: "\u2295",
+  otimes: "\u2297",
+  perp: "\u22A5",
+  sdot: "\u22C5",
+  lceil: "\u2308",
+  rceil: "\u2309",
+  lfloor: "\u230A",
+  rfloor: "\u230B",
+  lang: "\u2329",
+  rang: "\u232A",
+  loz: "\u25CA",
+  spades: "\u2660",
+  clubs: "\u2663",
+  hearts: "\u2665",
+  diams: "\u2666"
+};
+var _default = entities;
+exports.default = _default;

Nodejs/node_modules/@babel/parser/lib/plugins/placeholders.js

@@ -0,0 +1,204 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _types = require("../tokenizer/types");
+
+var N = _interopRequireWildcard(require("../types"));
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+_types.types.placeholder = new _types.TokenType("%%", {
+  startsExpr: true
+});
+
+var _default = superClass => class extends superClass {
+  parsePlaceholder(expectedNode) {
+    if (this.match(_types.types.placeholder)) {
+      const node = this.startNode();
+      this.next();
+      this.assertNoSpace("Unexpected space in placeholder.");
+      node.name = super.parseIdentifier(true);
+      this.assertNoSpace("Unexpected space in placeholder.");
+      this.expect(_types.types.placeholder);
+      return this.finishPlaceholder(node, expectedNode);
+    }
+  }
+
+  finishPlaceholder(node, expectedNode) {
+    const isFinished = !!(node.expectedNode && node.type === "Placeholder");
+    node.expectedNode = expectedNode;
+    return isFinished ? node : this.finishNode(node, "Placeholder");
+  }
+
+  getTokenFromCode(code) {
+    if (code === 37 && this.input.charCodeAt(this.state.pos + 1) === 37) {
+      return this.finishOp(_types.types.placeholder, 2);
+    }
+
+    return super.getTokenFromCode(...arguments);
+  }
+
+  parseExprAtom() {
+    return this.parsePlaceholder("Expression") || super.parseExprAtom(...arguments);
+  }
+
+  parseIdentifier() {
+    return this.parsePlaceholder("Identifier") || super.parseIdentifier(...arguments);
+  }
+
+  checkReservedWord(word) {
+    if (word !== undefined) super.checkReservedWord(...arguments);
+  }
+
+  parseBindingAtom() {
+    return this.parsePlaceholder("Pattern") || super.parseBindingAtom(...arguments);
+  }
+
+  checkLVal(expr) {
+    if (expr.type !== "Placeholder") super.checkLVal(...arguments);
+  }
+
+  toAssignable(node) {
+    if (node && node.type === "Placeholder" && node.expectedNode === "Expression") {
+      node.expectedNode = "Pattern";
+      return node;
+    }
+
+    return super.toAssignable(...arguments);
+  }
+
+  verifyBreakContinue(node) {
+    if (node.label && node.label.type === "Placeholder") return;
+    super.verifyBreakContinue(...arguments);
+  }
+
+  parseExpressionStatement(node, expr) {
+    if (expr.type !== "Placeholder" || expr.extra && expr.extra.parenthesized) {
+      return super.parseExpressionStatement(...arguments);
+    }
+
+    if (this.match(_types.types.colon)) {
+      const stmt = node;
+      stmt.label = this.finishPlaceholder(expr, "Identifier");
+      this.next();
+      stmt.body = this.parseStatement("label");
+      return this.finishNode(stmt, "LabeledStatement");
+    }
+
+    this.semicolon();
+    node.name = expr.name;
+    return this.finishPlaceholder(node, "Statement");
+  }
+
+  parseBlock() {
+    return this.parsePlaceholder("BlockStatement") || super.parseBlock(...arguments);
+  }
+
+  parseFunctionId() {
+    return this.parsePlaceholder("Identifier") || super.parseFunctionId(...arguments);
+  }
+
+  parseClass(node, isStatement, optionalId) {
+    const type = isStatement ? "ClassDeclaration" : "ClassExpression";
+    this.next();
+    this.takeDecorators(node);
+    const placeholder = this.parsePlaceholder("Identifier");
+
+    if (placeholder) {
+      if (this.match(_types.types._extends) || this.match(_types.types.placeholder) || this.match(_types.types.braceL)) {
+        node.id = placeholder;
+      } else if (optionalId || !isStatement) {
+        node.id = null;
+        node.body = this.finishPlaceholder(placeholder, "ClassBody");
+        return this.finishNode(node, type);
+      } else {
+        this.unexpected(null, "A class name is required");
+      }
+    } else {
+      this.parseClassId(node, isStatement, optionalId);
+    }
+
+    this.parseClassSuper(node);
+    node.body = this.parsePlaceholder("ClassBody") || this.parseClassBody(!!node.superClass);
+    return this.finishNode(node, type);
+  }
+
+  parseExport(node) {
+    const placeholder = this.parsePlaceholder("Identifier");
+    if (!placeholder) return super.parseExport(...arguments);
+
+    if (!this.isContextual("from") && !this.match(_types.types.comma)) {
+      node.specifiers = [];
+      node.source = null;
+      node.declaration = this.finishPlaceholder(placeholder, "Declaration");
+      return this.finishNode(node, "ExportNamedDeclaration");
+    }
+
+    this.expectPlugin("exportDefaultFrom");
+    const specifier = this.startNode();
+    specifier.exported = placeholder;
+    node.specifiers = [this.finishNode(specifier, "ExportDefaultSpecifier")];
+    return super.parseExport(node);
+  }
+
+  maybeParseExportDefaultSpecifier(node) {
+    if (node.specifiers && node.specifiers.length > 0) {
+      return true;
+    }
+
+    return super.maybeParseExportDefaultSpecifier(...arguments);
+  }
+
+  checkExport(node) {
+    const {
+      specifiers
+    } = node;
+
+    if (specifiers && specifiers.length) {
+      node.specifiers = specifiers.filter(node => node.exported.type === "Placeholder");
+    }
+
+    super.checkExport(node);
+    node.specifiers = specifiers;
+  }
+
+  parseImport(node) {
+    const placeholder = this.parsePlaceholder("Identifier");
+    if (!placeholder) return super.parseImport(...arguments);
+    node.specifiers = [];
+
+    if (!this.isContextual("from") && !this.match(_types.types.comma)) {
+      node.source = this.finishPlaceholder(placeholder, "StringLiteral");
+      this.semicolon();
+      return this.finishNode(node, "ImportDeclaration");
+    }
+
+    const specifier = this.startNodeAtNode(placeholder);
+    specifier.local = placeholder;
+    this.finishNode(specifier, "ImportDefaultSpecifier");
+    node.specifiers.push(specifier);
+
+    if (this.eat(_types.types.comma)) {
+      const hasStarImport = this.maybeParseStarImportSpecifier(node);
+      if (!hasStarImport) this.parseNamedImportSpecifiers(node);
+    }
+
+    this.expectContextual("from");
+    node.source = this.parseImportSource();
+    this.semicolon();
+    return this.finishNode(node, "ImportDeclaration");
+  }
+
+  parseImportSource() {
+    return this.parsePlaceholder("StringLiteral") || super.parseImportSource(...arguments);
+  }
+
+};
+
+exports.default = _default;

Nodejs/node_modules/@babel/parser/lib/plugins/typescript/scope.js

@@ -0,0 +1,94 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _scope = _interopRequireWildcard(require("../../util/scope"));
+
+var _scopeflags = require("../../util/scopeflags");
+
+var N = _interopRequireWildcard(require("../../types"));
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+class TypeScriptScope extends _scope.Scope {
+  constructor(...args) {
+    super(...args);
+    this.types = [];
+    this.enums = [];
+    this.constEnums = [];
+    this.classes = [];
+    this.exportOnlyBindings = [];
+  }
+
+}
+
+class TypeScriptScopeHandler extends _scope.default {
+  createScope(flags) {
+    return new TypeScriptScope(flags);
+  }
+
+  declareName(name, bindingType, pos) {
+    const scope = this.currentScope();
+
+    if (bindingType & _scopeflags.BIND_FLAGS_TS_EXPORT_ONLY) {
+      this.maybeExportDefined(scope, name);
+      scope.exportOnlyBindings.push(name);
+      return;
+    }
+
+    super.declareName(...arguments);
+
+    if (bindingType & _scopeflags.BIND_KIND_TYPE) {
+      if (!(bindingType & _scopeflags.BIND_KIND_VALUE)) {
+        this.checkRedeclarationInScope(scope, name, bindingType, pos);
+        this.maybeExportDefined(scope, name);
+      }
+
+      scope.types.push(name);
+    }
+
+    if (bindingType & _scopeflags.BIND_FLAGS_TS_ENUM) scope.enums.push(name);
+    if (bindingType & _scopeflags.BIND_FLAGS_TS_CONST_ENUM) scope.constEnums.push(name);
+    if (bindingType & _scopeflags.BIND_FLAGS_CLASS) scope.classes.push(name);
+  }
+
+  isRedeclaredInScope(scope, name, bindingType) {
+    if (scope.enums.indexOf(name) > -1) {
+      if (bindingType & _scopeflags.BIND_FLAGS_TS_ENUM) {
+        const isConst = !!(bindingType & _scopeflags.BIND_FLAGS_TS_CONST_ENUM);
+        const wasConst = scope.constEnums.indexOf(name) > -1;
+        return isConst !== wasConst;
+      }
+
+      return true;
+    }
+
+    if (bindingType & _scopeflags.BIND_FLAGS_CLASS && scope.classes.indexOf(name) > -1) {
+      if (scope.lexical.indexOf(name) > -1) {
+        return !!(bindingType & _scopeflags.BIND_KIND_VALUE);
+      } else {
+        return false;
+      }
+    }
+
+    if (bindingType & _scopeflags.BIND_KIND_TYPE && scope.types.indexOf(name) > -1) {
+      return true;
+    }
+
+    return super.isRedeclaredInScope(...arguments);
+  }
+
+  checkLocalExport(id) {
+    if (this.scopeStack[0].types.indexOf(id.name) === -1 && this.scopeStack[0].exportOnlyBindings.indexOf(id.name) === -1) {
+      super.checkLocalExport(id);
+    }
+  }
+
+}
+
+exports.default = TypeScriptScopeHandler;

Nodejs/node_modules/@babel/parser/lib/plugins/v8intrinsic.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _types = require("../tokenizer/types");
+
+var N = _interopRequireWildcard(require("../types"));
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+var _default = superClass => class extends superClass {
+  parseV8Intrinsic() {
+    if (this.match(_types.types.modulo)) {
+      const v8IntrinsicStart = this.state.start;
+      const node = this.startNode();
+      this.eat(_types.types.modulo);
+
+      if (this.match(_types.types.name)) {
+        const name = this.parseIdentifierName(this.state.start);
+        const identifier = this.createIdentifier(node, name);
+        identifier.type = "V8IntrinsicIdentifier";
+
+        if (this.match(_types.types.parenL)) {
+          return identifier;
+        }
+      }
+
+      this.unexpected(v8IntrinsicStart);
+    }
+  }
+
+  parseExprAtom() {
+    return this.parseV8Intrinsic() || super.parseExprAtom(...arguments);
+  }
+
+};
+
+exports.default = _default;

Nodejs/node_modules/@babel/parser/lib/tokenizer/context.js

@@ -0,0 +1,102 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.types = exports.TokContext = void 0;
+
+var _types = require("./types");
+
+var _whitespace = require("../util/whitespace");
+
+class TokContext {
+  constructor(token, isExpr, preserveSpace, override) {
+    this.token = token;
+    this.isExpr = !!isExpr;
+    this.preserveSpace = !!preserveSpace;
+    this.override = override;
+  }
+
+}
+
+exports.TokContext = TokContext;
+const types = {
+  braceStatement: new TokContext("{", false),
+  braceExpression: new TokContext("{", true),
+  templateQuasi: new TokContext("${", false),
+  parenStatement: new TokContext("(", false),
+  parenExpression: new TokContext("(", true),
+  template: new TokContext("`", true, true, p => p.readTmplToken()),
+  functionExpression: new TokContext("function", true),
+  functionStatement: new TokContext("function", false)
+};
+exports.types = types;
+
+_types.types.parenR.updateContext = _types.types.braceR.updateContext = function () {
+  if (this.state.context.length === 1) {
+    this.state.exprAllowed = true;
+    return;
+  }
+
+  let out = this.state.context.pop();
+
+  if (out === types.braceStatement && this.curContext().token === "function") {
+    out = this.state.context.pop();
+  }
+
+  this.state.exprAllowed = !out.isExpr;
+};
+
+_types.types.name.updateContext = function (prevType) {
+  let allowed = false;
+
+  if (prevType !== _types.types.dot) {
+    if (this.state.value === "of" && !this.state.exprAllowed || this.state.value === "yield" && this.prodParam.hasYield) {
+      allowed = true;
+    }
+  }
+
+  this.state.exprAllowed = allowed;
+
+  if (this.state.isIterator) {
+    this.state.isIterator = false;
+  }
+};
+
+_types.types.braceL.updateContext = function (prevType) {
+  this.state.context.push(this.braceIsBlock(prevType) ? types.braceStatement : types.braceExpression);
+  this.state.exprAllowed = true;
+};
+
+_types.types.dollarBraceL.updateContext = function () {
+  this.state.context.push(types.templateQuasi);
+  this.state.exprAllowed = true;
+};
+
+_types.types.parenL.updateContext = function (prevType) {
+  const statementParens = prevType === _types.types._if || prevType === _types.types._for || prevType === _types.types._with || prevType === _types.types._while;
+  this.state.context.push(statementParens ? types.parenStatement : types.parenExpression);
+  this.state.exprAllowed = true;
+};
+
+_types.types.incDec.updateContext = function () {};
+
+_types.types._function.updateContext = _types.types._class.updateContext = function (prevType) {
+  if (prevType.beforeExpr && prevType !== _types.types.semi && prevType !== _types.types._else && !(prevType === _types.types._return && _whitespace.lineBreak.test(this.input.slice(this.state.lastTokEnd, this.state.start))) && !((prevType === _types.types.colon || prevType === _types.types.braceL) && this.curContext() === types.b_stat)) {
+    this.state.context.push(types.functionExpression);
+  } else {
+    this.state.context.push(types.functionStatement);
+  }
+
+  this.state.exprAllowed = false;
+};
+
+_types.types.backQuote.updateContext = function () {
+  if (this.curContext() === types.template) {
+    this.state.context.pop();
+  } else {
+    this.state.context.push(types.template);
+  }
+
+  this.state.exprAllowed = false;
+};

Nodejs/node_modules/@babel/parser/lib/tokenizer/state.js

@@ -0,0 +1,98 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var N = _interopRequireWildcard(require("../types"));
+
+var _location = require("../util/location");
+
+var _context = require("./context");
+
+var _types2 = require("./types");
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+class State {
+  constructor() {
+    this.errors = [];
+    this.potentialArrowAt = -1;
+    this.noArrowAt = [];
+    this.noArrowParamsConversionAt = [];
+    this.inParameters = false;
+    this.maybeInArrowParameters = false;
+    this.inPipeline = false;
+    this.inType = false;
+    this.noAnonFunctionType = false;
+    this.inPropertyName = false;
+    this.hasFlowComment = false;
+    this.isIterator = false;
+    this.topicContext = {
+      maxNumOfResolvableTopics: 0,
+      maxTopicIndex: null
+    };
+    this.soloAwait = false;
+    this.inFSharpPipelineDirectBody = false;
+    this.labels = [];
+    this.decoratorStack = [[]];
+    this.yieldPos = -1;
+    this.awaitPos = -1;
+    this.comments = [];
+    this.trailingComments = [];
+    this.leadingComments = [];
+    this.commentStack = [];
+    this.commentPreviousNode = null;
+    this.pos = 0;
+    this.lineStart = 0;
+    this.type = _types2.types.eof;
+    this.value = null;
+    this.start = 0;
+    this.end = 0;
+    this.lastTokEndLoc = null;
+    this.lastTokStartLoc = null;
+    this.lastTokStart = 0;
+    this.lastTokEnd = 0;
+    this.context = [_context.types.braceStatement];
+    this.exprAllowed = true;
+    this.containsEsc = false;
+    this.containsOctal = false;
+    this.octalPosition = null;
+    this.exportedIdentifiers = [];
+    this.tokensLength = 0;
+  }
+
+  init(options) {
+    this.strict = options.strictMode === false ? false : options.sourceType === "module";
+    this.curLine = options.startLine;
+    this.startLoc = this.endLoc = this.curPosition();
+  }
+
+  curPosition() {
+    return new _location.Position(this.curLine, this.pos - this.lineStart);
+  }
+
+  clone(skipArrays) {
+    const state = new State();
+    const keys = Object.keys(this);
+
+    for (let i = 0, length = keys.length; i < length; i++) {
+      const key = keys[i];
+      let val = this[key];
+
+      if (!skipArrays && Array.isArray(val)) {
+        val = val.slice();
+      }
+
+      state[key] = val;
+    }
+
+    return state;
+  }
+
+}
+
+exports.default = State;

Nodejs/node_modules/@babel/parser/lib/tokenizer/types.js

@@ -0,0 +1,267 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.types = exports.keywords = exports.TokenType = void 0;
+const beforeExpr = true;
+const startsExpr = true;
+const isLoop = true;
+const isAssign = true;
+const prefix = true;
+const postfix = true;
+
+class TokenType {
+  constructor(label, conf = {}) {
+    this.label = label;
+    this.keyword = conf.keyword;
+    this.beforeExpr = !!conf.beforeExpr;
+    this.startsExpr = !!conf.startsExpr;
+    this.rightAssociative = !!conf.rightAssociative;
+    this.isLoop = !!conf.isLoop;
+    this.isAssign = !!conf.isAssign;
+    this.prefix = !!conf.prefix;
+    this.postfix = !!conf.postfix;
+    this.binop = conf.binop != null ? conf.binop : null;
+    this.updateContext = null;
+  }
+
+}
+
+exports.TokenType = TokenType;
+const keywords = new Map();
+exports.keywords = keywords;
+
+function createKeyword(name, options = {}) {
+  options.keyword = name;
+  const token = new TokenType(name, options);
+  keywords.set(name, token);
+  return token;
+}
+
+function createBinop(name, binop) {
+  return new TokenType(name, {
+    beforeExpr,
+    binop
+  });
+}
+
+const types = {
+  num: new TokenType("num", {
+    startsExpr
+  }),
+  bigint: new TokenType("bigint", {
+    startsExpr
+  }),
+  regexp: new TokenType("regexp", {
+    startsExpr
+  }),
+  string: new TokenType("string", {
+    startsExpr
+  }),
+  name: new TokenType("name", {
+    startsExpr
+  }),
+  eof: new TokenType("eof"),
+  bracketL: new TokenType("[", {
+    beforeExpr,
+    startsExpr
+  }),
+  bracketR: new TokenType("]"),
+  braceL: new TokenType("{", {
+    beforeExpr,
+    startsExpr
+  }),
+  braceBarL: new TokenType("{|", {
+    beforeExpr,
+    startsExpr
+  }),
+  braceR: new TokenType("}"),
+  braceBarR: new TokenType("|}"),
+  parenL: new TokenType("(", {
+    beforeExpr,
+    startsExpr
+  }),
+  parenR: new TokenType(")"),
+  comma: new TokenType(",", {
+    beforeExpr
+  }),
+  semi: new TokenType(";", {
+    beforeExpr
+  }),
+  colon: new TokenType(":", {
+    beforeExpr
+  }),
+  doubleColon: new TokenType("::", {
+    beforeExpr
+  }),
+  dot: new TokenType("."),
+  question: new TokenType("?", {
+    beforeExpr
+  }),
+  questionDot: new TokenType("?."),
+  arrow: new TokenType("=>", {
+    beforeExpr
+  }),
+  template: new TokenType("template"),
+  ellipsis: new TokenType("...", {
+    beforeExpr
+  }),
+  backQuote: new TokenType("`", {
+    startsExpr
+  }),
+  dollarBraceL: new TokenType("${", {
+    beforeExpr,
+    startsExpr
+  }),
+  at: new TokenType("@"),
+  hash: new TokenType("#", {
+    startsExpr
+  }),
+  interpreterDirective: new TokenType("#!..."),
+  eq: new TokenType("=", {
+    beforeExpr,
+    isAssign
+  }),
+  assign: new TokenType("_=", {
+    beforeExpr,
+    isAssign
+  }),
+  incDec: new TokenType("++/--", {
+    prefix,
+    postfix,
+    startsExpr
+  }),
+  bang: new TokenType("!", {
+    beforeExpr,
+    prefix,
+    startsExpr
+  }),
+  tilde: new TokenType("~", {
+    beforeExpr,
+    prefix,
+    startsExpr
+  }),
+  pipeline: createBinop("|>", 0),
+  nullishCoalescing: createBinop("??", 1),
+  logicalOR: createBinop("||", 1),
+  logicalAND: createBinop("&&", 2),
+  bitwiseOR: createBinop("|", 3),
+  bitwiseXOR: createBinop("^", 4),
+  bitwiseAND: createBinop("&", 5),
+  equality: createBinop("==/!=/===/!==", 6),
+  relational: createBinop("</>/<=/>=", 7),
+  bitShift: createBinop("<</>>/>>>", 8),
+  plusMin: new TokenType("+/-", {
+    beforeExpr,
+    binop: 9,
+    prefix,
+    startsExpr
+  }),
+  modulo: new TokenType("%", {
+    beforeExpr,
+    binop: 10,
+    startsExpr
+  }),
+  star: createBinop("*", 10),
+  slash: createBinop("/", 10),
+  exponent: new TokenType("**", {
+    beforeExpr,
+    binop: 11,
+    rightAssociative: true
+  }),
+  _break: createKeyword("break"),
+  _case: createKeyword("case", {
+    beforeExpr
+  }),
+  _catch: createKeyword("catch"),
+  _continue: createKeyword("continue"),
+  _debugger: createKeyword("debugger"),
+  _default: createKeyword("default", {
+    beforeExpr
+  }),
+  _do: createKeyword("do", {
+    isLoop,
+    beforeExpr
+  }),
+  _else: createKeyword("else", {
+    beforeExpr
+  }),
+  _finally: createKeyword("finally"),
+  _for: createKeyword("for", {
+    isLoop
+  }),
+  _function: createKeyword("function", {
+    startsExpr
+  }),
+  _if: createKeyword("if"),
+  _return: createKeyword("return", {
+    beforeExpr
+  }),
+  _switch: createKeyword("switch"),
+  _throw: createKeyword("throw", {
+    beforeExpr,
+    prefix,
+    startsExpr
+  }),
+  _try: createKeyword("try"),
+  _var: createKeyword("var"),
+  _const: createKeyword("const"),
+  _while: createKeyword("while", {
+    isLoop
+  }),
+  _with: createKeyword("with"),
+  _new: createKeyword("new", {
+    beforeExpr,
+    startsExpr
+  }),
+  _this: createKeyword("this", {
+    startsExpr
+  }),
+  _super: createKeyword("super", {
+    startsExpr
+  }),
+  _class: createKeyword("class", {
+    startsExpr
+  }),
+  _extends: createKeyword("extends", {
+    beforeExpr
+  }),
+  _export: createKeyword("export"),
+  _import: createKeyword("import", {
+    startsExpr
+  }),
+  _null: createKeyword("null", {
+    startsExpr
+  }),
+  _true: createKeyword("true", {
+    startsExpr
+  }),
+  _false: createKeyword("false", {
+    startsExpr
+  }),
+  _in: createKeyword("in", {
+    beforeExpr,
+    binop: 7
+  }),
+  _instanceof: createKeyword("instanceof", {
+    beforeExpr,
+    binop: 7
+  }),
+  _typeof: createKeyword("typeof", {
+    beforeExpr,
+    prefix,
+    startsExpr
+  }),
+  _void: createKeyword("void", {
+    beforeExpr,
+    prefix,
+    startsExpr
+  }),
+  _delete: createKeyword("delete", {
+    beforeExpr,
+    prefix,
+    startsExpr
+  })
+};
+exports.types = types;

Nodejs/node_modules/@babel/parser/lib/util/class-scope.js

@@ -0,0 +1,101 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.ClassScope = void 0;
+
+var _scopeflags = require("./scopeflags");
+
+class ClassScope {
+  constructor() {
+    this.privateNames = new Set();
+    this.loneAccessors = new Map();
+    this.undefinedPrivateNames = new Map();
+  }
+
+}
+
+exports.ClassScope = ClassScope;
+
+class ClassScopeHandler {
+  constructor(raise) {
+    this.stack = [];
+    this.undefinedPrivateNames = new Map();
+    this.raise = raise;
+  }
+
+  current() {
+    return this.stack[this.stack.length - 1];
+  }
+
+  enter() {
+    this.stack.push(new ClassScope());
+  }
+
+  exit() {
+    const oldClassScope = this.stack.pop();
+    const current = this.current();
+
+    for (let _i = 0, _Array$from = Array.from(oldClassScope.undefinedPrivateNames); _i < _Array$from.length; _i++) {
+      const [name, pos] = _Array$from[_i];
+
+      if (current) {
+        if (!current.undefinedPrivateNames.has(name)) {
+          current.undefinedPrivateNames.set(name, pos);
+        }
+      } else {
+        this.raiseUndeclaredPrivateName(name, pos);
+      }
+    }
+  }
+
+  declarePrivateName(name, elementType, pos) {
+    const classScope = this.current();
+    let redefined = classScope.privateNames.has(name);
+
+    if (elementType & _scopeflags.CLASS_ELEMENT_KIND_ACCESSOR) {
+      const accessor = redefined && classScope.loneAccessors.get(name);
+
+      if (accessor) {
+        const oldStatic = accessor & _scopeflags.CLASS_ELEMENT_FLAG_STATIC;
+        const newStatic = elementType & _scopeflags.CLASS_ELEMENT_FLAG_STATIC;
+        const oldKind = accessor & _scopeflags.CLASS_ELEMENT_KIND_ACCESSOR;
+        const newKind = elementType & _scopeflags.CLASS_ELEMENT_KIND_ACCESSOR;
+        redefined = oldKind === newKind || oldStatic !== newStatic;
+        if (!redefined) classScope.loneAccessors.delete(name);
+      } else if (!redefined) {
+        classScope.loneAccessors.set(name, elementType);
+      }
+    }
+
+    if (redefined) {
+      this.raise(pos, `Duplicate private name #${name}`);
+    }
+
+    classScope.privateNames.add(name);
+    classScope.undefinedPrivateNames.delete(name);
+  }
+
+  usePrivateName(name, pos) {
+    let classScope;
+
+    for (let _i2 = 0, _this$stack = this.stack; _i2 < _this$stack.length; _i2++) {
+      classScope = _this$stack[_i2];
+      if (classScope.privateNames.has(name)) return;
+    }
+
+    if (classScope) {
+      classScope.undefinedPrivateNames.set(name, pos);
+    } else {
+      this.raiseUndeclaredPrivateName(name, pos);
+    }
+  }
+
+  raiseUndeclaredPrivateName(name, pos) {
+    this.raise(pos, `Private name #${name} is not defined`);
+  }
+
+}
+
+exports.default = ClassScopeHandler;

Nodejs/node_modules/@babel/parser/lib/util/identifier.js

@@ -0,0 +1,99 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isStrictReservedWord = isStrictReservedWord;
+exports.isStrictBindOnlyReservedWord = isStrictBindOnlyReservedWord;
+exports.isStrictBindReservedWord = isStrictBindReservedWord;
+exports.isKeyword = isKeyword;
+exports.isIdentifierStart = isIdentifierStart;
+exports.isIteratorStart = isIteratorStart;
+exports.isIdentifierChar = isIdentifierChar;
+exports.keywordRelationalOperator = exports.isReservedWord = void 0;
+
+var _types = require("../tokenizer/types");
+
+const reservedWords = {
+  strict: ["implements", "interface", "let", "package", "private", "protected", "public", "static", "yield"],
+  strictBind: ["eval", "arguments"]
+};
+const reservedWordsStrictSet = new Set(reservedWords.strict);
+const reservedWordsStrictBindSet = new Set(reservedWords.strictBind);
+
+const isReservedWord = (word, inModule) => {
+  return inModule && word === "await" || word === "enum";
+};
+
+exports.isReservedWord = isReservedWord;
+
+function isStrictReservedWord(word, inModule) {
+  return isReservedWord(word, inModule) || reservedWordsStrictSet.has(word);
+}
+
+function isStrictBindOnlyReservedWord(word) {
+  return reservedWordsStrictBindSet.has(word);
+}
+
+function isStrictBindReservedWord(word, inModule) {
+  return isStrictReservedWord(word, inModule) || isStrictBindOnlyReservedWord(word);
+}
+
+function isKeyword(word) {
+  return _types.keywords.has(word);
+}
+
+const keywordRelationalOperator = /^in(stanceof)?$/;
+exports.keywordRelationalOperator = keywordRelationalOperator;
+let nonASCIIidentifierStartChars = "\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u037f\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u052f\u0531-\u0556\u0559\u0560-\u0588\u05d0-\u05ea\u05ef-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u0860-\u086a\u08a0-\u08b4\u08b6-\u08bd\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u09fc\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0af9\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3d\u0c58-\u0c5a\u0c60\u0c61\u0c80\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d54-\u0d56\u0d5f-\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f5\u13f8-\u13fd\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f8\u1700-\u170c\u170e-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1878\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191e\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4b\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1c80-\u1c88\u1c90-\u1cba\u1cbd-\u1cbf\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5\u1cf6\u1cfa\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2118-\u211d\u2124\u2126\u2128\u212a-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309b-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312f\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fef\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua69d\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua7bf\ua7c2-\ua7c6\ua7f7-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua8fd\ua8fe\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\ua9e0-\ua9e4\ua9e6-\ua9ef\ua9fa-\ua9fe\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa7e-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab5a\uab5c-\uab67\uab70-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc";
+let nonASCIIidentifierChars = "\u200c\u200d\xb7\u0300-\u036f\u0387\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u0669\u0670\u06d6-\u06dc\u06df-\u06e4\u06e7\u06e8\u06ea-\u06ed\u06f0-\u06f9\u0711\u0730-\u074a\u07a6-\u07b0\u07c0-\u07c9\u07eb-\u07f3\u07fd\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0859-\u085b\u08d3-\u08e1\u08e3-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09cb-\u09cd\u09d7\u09e2\u09e3\u09e6-\u09ef\u09fe\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2\u0ae3\u0ae6-\u0aef\u0afa-\u0aff\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b56\u0b57\u0b62\u0b63\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c00-\u0c04\u0c3e-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0c66-\u0c6f\u0c81-\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0ce6-\u0cef\u0d00-\u0d03\u0d3b\u0d3c\u0d3e-\u0d44\u0d46-\u0d48\u0d4a-\u0d4d\u0d57\u0d62\u0d63\u0d66-\u0d6f\u0d82\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2\u0df3\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0e50-\u0e59\u0eb1\u0eb4-\u0ebc\u0ec8-\u0ecd\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e\u0f3f\u0f71-\u0f84\u0f86\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u102b-\u103e\u1040-\u1049\u1056-\u1059\u105e-\u1060\u1062-\u1064\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u1369-\u1371\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17b4-\u17d3\u17dd\u17e0-\u17e9\u180b-\u180d\u1810-\u1819\u18a9\u1920-\u192b\u1930-\u193b\u1946-\u194f\u19d0-\u19da\u1a17-\u1a1b\u1a55-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1ab0-\u1abd\u1b00-\u1b04\u1b34-\u1b44\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1b82\u1ba1-\u1bad\u1bb0-\u1bb9\u1be6-\u1bf3\u1c24-\u1c37\u1c40-\u1c49\u1c50-\u1c59\u1cd0-\u1cd2\u1cd4-\u1ce8\u1ced\u1cf4\u1cf7-\u1cf9\u1dc0-\u1df9\u1dfb-\u1dff\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2cef-\u2cf1\u2d7f\u2de0-\u2dff\u302a-\u302f\u3099\u309a\ua620-\ua629\ua66f\ua674-\ua67d\ua69e\ua69f\ua6f0\ua6f1\ua802\ua806\ua80b\ua823-\ua827\ua880\ua881\ua8b4-\ua8c5\ua8d0-\ua8d9\ua8e0-\ua8f1\ua8ff-\ua909\ua926-\ua92d\ua947-\ua953\ua980-\ua983\ua9b3-\ua9c0\ua9d0-\ua9d9\ua9e5\ua9f0-\ua9f9\uaa29-\uaa36\uaa43\uaa4c\uaa4d\uaa50-\uaa59\uaa7b-\uaa7d\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uaaeb-\uaaef\uaaf5\uaaf6\uabe3-\uabea\uabec\uabed\uabf0-\uabf9\ufb1e\ufe00-\ufe0f\ufe20-\ufe2f\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f";
+const nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
+const nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
+nonASCIIidentifierStartChars = nonASCIIidentifierChars = null;
+const astralIdentifierStartCodes = [0, 11, 2, 25, 2, 18, 2, 1, 2, 14, 3, 13, 35, 122, 70, 52, 268, 28, 4, 48, 48, 31, 14, 29, 6, 37, 11, 29, 3, 35, 5, 7, 2, 4, 43, 157, 19, 35, 5, 35, 5, 39, 9, 51, 157, 310, 10, 21, 11, 7, 153, 5, 3, 0, 2, 43, 2, 1, 4, 0, 3, 22, 11, 22, 10, 30, 66, 18, 2, 1, 11, 21, 11, 25, 71, 55, 7, 1, 65, 0, 16, 3, 2, 2, 2, 28, 43, 28, 4, 28, 36, 7, 2, 27, 28, 53, 11, 21, 11, 18, 14, 17, 111, 72, 56, 50, 14, 50, 14, 35, 477, 28, 11, 0, 9, 21, 155, 22, 13, 52, 76, 44, 33, 24, 27, 35, 30, 0, 12, 34, 4, 0, 13, 47, 15, 3, 22, 0, 2, 0, 36, 17, 2, 24, 85, 6, 2, 0, 2, 3, 2, 14, 2, 9, 8, 46, 39, 7, 3, 1, 3, 21, 2, 6, 2, 1, 2, 4, 4, 0, 19, 0, 13, 4, 159, 52, 19, 3, 21, 0, 33, 47, 21, 1, 2, 0, 185, 46, 42, 3, 37, 47, 21, 0, 60, 42, 14, 0, 72, 26, 230, 43, 117, 63, 32, 0, 161, 7, 3, 38, 17, 0, 2, 0, 29, 0, 11, 39, 8, 0, 22, 0, 12, 45, 20, 0, 35, 56, 264, 8, 2, 36, 18, 0, 50, 29, 113, 6, 2, 1, 2, 37, 22, 0, 26, 5, 2, 1, 2, 31, 15, 0, 328, 18, 270, 921, 103, 110, 18, 195, 2749, 1070, 4050, 582, 8634, 568, 8, 30, 114, 29, 19, 47, 17, 3, 32, 20, 6, 18, 689, 63, 129, 74, 6, 0, 67, 12, 65, 1, 2, 0, 29, 6135, 9, 754, 9486, 286, 50, 2, 18, 3, 9, 395, 2309, 106, 6, 12, 4, 8, 8, 9, 5991, 84, 2, 70, 2, 1, 3, 0, 3, 1, 3, 3, 2, 11, 2, 0, 2, 6, 2, 64, 2, 3, 3, 7, 2, 6, 2, 27, 2, 3, 2, 4, 2, 0, 4, 6, 2, 339, 3, 24, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 7, 2357, 44, 11, 6, 17, 0, 370, 43, 1301, 196, 60, 67, 8, 0, 1205, 3, 2, 26, 2, 1, 2, 0, 3, 0, 2, 9, 2, 3, 2, 0, 2, 0, 7, 0, 5, 0, 2, 0, 2, 0, 2, 2, 2, 1, 2, 0, 3, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 1, 2, 0, 3, 3, 2, 6, 2, 3, 2, 3, 2, 0, 2, 9, 2, 16, 6, 2, 2, 4, 2, 16, 4421, 42710, 42, 4148, 12, 221, 3, 5761, 15, 7472, 3104, 541];
+const astralIdentifierCodes = [509, 0, 227, 0, 150, 4, 294, 9, 1368, 2, 2, 1, 6, 3, 41, 2, 5, 0, 166, 1, 574, 3, 9, 9, 525, 10, 176, 2, 54, 14, 32, 9, 16, 3, 46, 10, 54, 9, 7, 2, 37, 13, 2, 9, 6, 1, 45, 0, 13, 2, 49, 13, 9, 3, 4, 9, 83, 11, 7, 0, 161, 11, 6, 9, 7, 3, 56, 1, 2, 6, 3, 1, 3, 2, 10, 0, 11, 1, 3, 6, 4, 4, 193, 17, 10, 9, 5, 0, 82, 19, 13, 9, 214, 6, 3, 8, 28, 1, 83, 16, 16, 9, 82, 12, 9, 9, 84, 14, 5, 9, 243, 14, 166, 9, 232, 6, 3, 6, 4, 0, 29, 9, 41, 6, 2, 3, 9, 0, 10, 10, 47, 15, 406, 7, 2, 7, 17, 9, 57, 21, 2, 13, 123, 5, 4, 0, 2, 1, 2, 6, 2, 0, 9, 9, 49, 4, 2, 1, 2, 4, 9, 9, 330, 3, 19306, 9, 135, 4, 60, 6, 26, 9, 1014, 0, 2, 54, 8, 3, 19723, 1, 5319, 4, 4, 5, 9, 7, 3, 6, 31, 3, 149, 2, 1418, 49, 513, 54, 5, 49, 9, 0, 15, 0, 23, 4, 2, 14, 1361, 6, 2, 16, 3, 6, 2, 1, 2, 4, 262, 6, 10, 9, 419, 13, 1495, 6, 110, 6, 6, 9, 792487, 239];
+
+function isInAstralSet(code, set) {
+  let pos = 0x10000;
+
+  for (let i = 0, length = set.length; i < length; i += 2) {
+    pos += set[i];
+    if (pos > code) return false;
+    pos += set[i + 1];
+    if (pos >= code) return true;
+  }
+
+  return false;
+}
+
+function isIdentifierStart(code) {
+  if (code < 65) return code === 36;
+  if (code <= 90) return true;
+  if (code < 97) return code === 95;
+  if (code <= 122) return true;
+
+  if (code <= 0xffff) {
+    return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code));
+  }
+
+  return isInAstralSet(code, astralIdentifierStartCodes);
+}
+
+function isIteratorStart(current, next) {
+  return current === 64 && next === 64;
+}
+
+function isIdentifierChar(code) {
+  if (code < 48) return code === 36;
+  if (code < 58) return true;
+  if (code < 65) return false;
+  if (code <= 90) return true;
+  if (code < 97) return code === 95;
+  if (code <= 122) return true;
+
+  if (code <= 0xffff) {
+    return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));
+  }
+
+  return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes);
+}

Nodejs/node_modules/@babel/parser/lib/util/location.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getLineInfo = getLineInfo;
+exports.SourceLocation = exports.Position = void 0;
+
+var _whitespace = require("./whitespace");
+
+class Position {
+  constructor(line, col) {
+    this.line = line;
+    this.column = col;
+  }
+
+}
+
+exports.Position = Position;
+
+class SourceLocation {
+  constructor(start, end) {
+    this.start = start;
+    this.end = end;
+  }
+
+}
+
+exports.SourceLocation = SourceLocation;
+
+function getLineInfo(input, offset) {
+  let line = 1;
+  let lineStart = 0;
+  let match;
+  _whitespace.lineBreakG.lastIndex = 0;
+
+  while ((match = _whitespace.lineBreakG.exec(input)) && match.index < offset) {
+    line++;
+    lineStart = _whitespace.lineBreakG.lastIndex;
+  }
+
+  return new Position(line, offset - lineStart);
+}

Nodejs/node_modules/@babel/parser/lib/util/production-parameter.js

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.functionFlags = functionFlags;
+exports.default = exports.PARAM_RETURN = exports.PARAM_AWAIT = exports.PARAM_YIELD = exports.PARAM = void 0;
+const PARAM = 0b000,
+      PARAM_YIELD = 0b001,
+      PARAM_AWAIT = 0b010,
+      PARAM_RETURN = 0b100;
+exports.PARAM_RETURN = PARAM_RETURN;
+exports.PARAM_AWAIT = PARAM_AWAIT;
+exports.PARAM_YIELD = PARAM_YIELD;
+exports.PARAM = PARAM;
+
+class ProductionParameterHandler {
+  constructor() {
+    this.stacks = [];
+  }
+
+  enter(flags) {
+    this.stacks.push(flags);
+  }
+
+  exit() {
+    this.stacks.pop();
+  }
+
+  currentFlags() {
+    return this.stacks[this.stacks.length - 1];
+  }
+
+  get hasAwait() {
+    return (this.currentFlags() & PARAM_AWAIT) > 0;
+  }
+
+  get hasYield() {
+    return (this.currentFlags() & PARAM_YIELD) > 0;
+  }
+
+  get hasReturn() {
+    return (this.currentFlags() & PARAM_RETURN) > 0;
+  }
+
+}
+
+exports.default = ProductionParameterHandler;
+
+function functionFlags(isAsync, isGenerator) {
+  return (isAsync ? PARAM_AWAIT : 0) | (isGenerator ? PARAM_YIELD : 0);
+}

Nodejs/node_modules/@babel/parser/lib/util/scope.js

@@ -0,0 +1,165 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.Scope = void 0;
+
+var _scopeflags = require("./scopeflags");
+
+var N = _interopRequireWildcard(require("../types"));
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+class Scope {
+  constructor(flags) {
+    this.var = [];
+    this.lexical = [];
+    this.functions = [];
+    this.flags = flags;
+  }
+
+}
+
+exports.Scope = Scope;
+
+class ScopeHandler {
+  constructor(raise, inModule) {
+    this.scopeStack = [];
+    this.undefinedExports = new Map();
+    this.undefinedPrivateNames = new Map();
+    this.raise = raise;
+    this.inModule = inModule;
+  }
+
+  get inFunction() {
+    return (this.currentVarScope().flags & _scopeflags.SCOPE_FUNCTION) > 0;
+  }
+
+  get allowSuper() {
+    return (this.currentThisScope().flags & _scopeflags.SCOPE_SUPER) > 0;
+  }
+
+  get allowDirectSuper() {
+    return (this.currentThisScope().flags & _scopeflags.SCOPE_DIRECT_SUPER) > 0;
+  }
+
+  get inClass() {
+    return (this.currentThisScope().flags & _scopeflags.SCOPE_CLASS) > 0;
+  }
+
+  get inNonArrowFunction() {
+    return (this.currentThisScope().flags & _scopeflags.SCOPE_FUNCTION) > 0;
+  }
+
+  get treatFunctionsAsVar() {
+    return this.treatFunctionsAsVarInScope(this.currentScope());
+  }
+
+  createScope(flags) {
+    return new Scope(flags);
+  }
+
+  enter(flags) {
+    this.scopeStack.push(this.createScope(flags));
+  }
+
+  exit() {
+    this.scopeStack.pop();
+  }
+
+  treatFunctionsAsVarInScope(scope) {
+    return !!(scope.flags & _scopeflags.SCOPE_FUNCTION || !this.inModule && scope.flags & _scopeflags.SCOPE_PROGRAM);
+  }
+
+  declareName(name, bindingType, pos) {
+    let scope = this.currentScope();
+
+    if (bindingType & _scopeflags.BIND_SCOPE_LEXICAL || bindingType & _scopeflags.BIND_SCOPE_FUNCTION) {
+      this.checkRedeclarationInScope(scope, name, bindingType, pos);
+
+      if (bindingType & _scopeflags.BIND_SCOPE_FUNCTION) {
+        scope.functions.push(name);
+      } else {
+        scope.lexical.push(name);
+      }
+
+      if (bindingType & _scopeflags.BIND_SCOPE_LEXICAL) {
+        this.maybeExportDefined(scope, name);
+      }
+    } else if (bindingType & _scopeflags.BIND_SCOPE_VAR) {
+      for (let i = this.scopeStack.length - 1; i >= 0; --i) {
+        scope = this.scopeStack[i];
+        this.checkRedeclarationInScope(scope, name, bindingType, pos);
+        scope.var.push(name);
+        this.maybeExportDefined(scope, name);
+        if (scope.flags & _scopeflags.SCOPE_VAR) break;
+      }
+    }
+
+    if (this.inModule && scope.flags & _scopeflags.SCOPE_PROGRAM) {
+      this.undefinedExports.delete(name);
+    }
+  }
+
+  maybeExportDefined(scope, name) {
+    if (this.inModule && scope.flags & _scopeflags.SCOPE_PROGRAM) {
+      this.undefinedExports.delete(name);
+    }
+  }
+
+  checkRedeclarationInScope(scope, name, bindingType, pos) {
+    if (this.isRedeclaredInScope(scope, name, bindingType)) {
+      this.raise(pos, `Identifier '${name}' has already been declared`);
+    }
+  }
+
+  isRedeclaredInScope(scope, name, bindingType) {
+    if (!(bindingType & _scopeflags.BIND_KIND_VALUE)) return false;
+
+    if (bindingType & _scopeflags.BIND_SCOPE_LEXICAL) {
+      return scope.lexical.indexOf(name) > -1 || scope.functions.indexOf(name) > -1 || scope.var.indexOf(name) > -1;
+    }
+
+    if (bindingType & _scopeflags.BIND_SCOPE_FUNCTION) {
+      return scope.lexical.indexOf(name) > -1 || !this.treatFunctionsAsVarInScope(scope) && scope.var.indexOf(name) > -1;
+    }
+
+    return scope.lexical.indexOf(name) > -1 && !(scope.flags & _scopeflags.SCOPE_SIMPLE_CATCH && scope.lexical[0] === name) || !this.treatFunctionsAsVarInScope(scope) && scope.functions.indexOf(name) > -1;
+  }
+
+  checkLocalExport(id) {
+    if (this.scopeStack[0].lexical.indexOf(id.name) === -1 && this.scopeStack[0].var.indexOf(id.name) === -1 && this.scopeStack[0].functions.indexOf(id.name) === -1) {
+      this.undefinedExports.set(id.name, id.start);
+    }
+  }
+
+  currentScope() {
+    return this.scopeStack[this.scopeStack.length - 1];
+  }
+
+  currentVarScope() {
+    for (let i = this.scopeStack.length - 1;; i--) {
+      const scope = this.scopeStack[i];
+
+      if (scope.flags & _scopeflags.SCOPE_VAR) {
+        return scope;
+      }
+    }
+  }
+
+  currentThisScope() {
+    for (let i = this.scopeStack.length - 1;; i--) {
+      const scope = this.scopeStack[i];
+
+      if ((scope.flags & _scopeflags.SCOPE_VAR || scope.flags & _scopeflags.SCOPE_CLASS) && !(scope.flags & _scopeflags.SCOPE_ARROW)) {
+        return scope;
+      }
+    }
+  }
+
+}
+
+exports.default = ScopeHandler;

Nodejs/node_modules/@babel/parser/lib/util/scopeflags.js

@@ -0,0 +1,90 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CLASS_ELEMENT_OTHER = exports.CLASS_ELEMENT_INSTANCE_SETTER = exports.CLASS_ELEMENT_INSTANCE_GETTER = exports.CLASS_ELEMENT_STATIC_SETTER = exports.CLASS_ELEMENT_STATIC_GETTER = exports.CLASS_ELEMENT_KIND_ACCESSOR = exports.CLASS_ELEMENT_KIND_SETTER = exports.CLASS_ELEMENT_KIND_GETTER = exports.CLASS_ELEMENT_FLAG_STATIC = exports.BIND_TS_NAMESPACE = exports.BIND_TS_CONST_ENUM = exports.BIND_OUTSIDE = exports.BIND_NONE = exports.BIND_TS_AMBIENT = exports.BIND_TS_ENUM = exports.BIND_TS_TYPE = exports.BIND_TS_INTERFACE = exports.BIND_FUNCTION = exports.BIND_VAR = exports.BIND_LEXICAL = exports.BIND_CLASS = exports.BIND_FLAGS_TS_EXPORT_ONLY = exports.BIND_FLAGS_TS_CONST_ENUM = exports.BIND_FLAGS_TS_ENUM = exports.BIND_FLAGS_CLASS = exports.BIND_FLAGS_NONE = exports.BIND_SCOPE_OUTSIDE = exports.BIND_SCOPE_FUNCTION = exports.BIND_SCOPE_LEXICAL = exports.BIND_SCOPE_VAR = exports.BIND_KIND_TYPE = exports.BIND_KIND_VALUE = exports.SCOPE_VAR = exports.SCOPE_TS_MODULE = exports.SCOPE_CLASS = exports.SCOPE_DIRECT_SUPER = exports.SCOPE_SUPER = exports.SCOPE_SIMPLE_CATCH = exports.SCOPE_ARROW = exports.SCOPE_FUNCTION = exports.SCOPE_PROGRAM = exports.SCOPE_OTHER = void 0;
+const SCOPE_OTHER = 0b00000000,
+      SCOPE_PROGRAM = 0b00000001,
+      SCOPE_FUNCTION = 0b00000010,
+      SCOPE_ARROW = 0b00000100,
+      SCOPE_SIMPLE_CATCH = 0b00001000,
+      SCOPE_SUPER = 0b00010000,
+      SCOPE_DIRECT_SUPER = 0b00100000,
+      SCOPE_CLASS = 0b01000000,
+      SCOPE_TS_MODULE = 0b10000000,
+      SCOPE_VAR = SCOPE_PROGRAM | SCOPE_FUNCTION | SCOPE_TS_MODULE;
+exports.SCOPE_VAR = SCOPE_VAR;
+exports.SCOPE_TS_MODULE = SCOPE_TS_MODULE;
+exports.SCOPE_CLASS = SCOPE_CLASS;
+exports.SCOPE_DIRECT_SUPER = SCOPE_DIRECT_SUPER;
+exports.SCOPE_SUPER = SCOPE_SUPER;
+exports.SCOPE_SIMPLE_CATCH = SCOPE_SIMPLE_CATCH;
+exports.SCOPE_ARROW = SCOPE_ARROW;
+exports.SCOPE_FUNCTION = SCOPE_FUNCTION;
+exports.SCOPE_PROGRAM = SCOPE_PROGRAM;
+exports.SCOPE_OTHER = SCOPE_OTHER;
+const BIND_KIND_VALUE = 0b00000000001,
+      BIND_KIND_TYPE = 0b00000000010,
+      BIND_SCOPE_VAR = 0b00000000100,
+      BIND_SCOPE_LEXICAL = 0b00000001000,
+      BIND_SCOPE_FUNCTION = 0b00000010000,
+      BIND_SCOPE_OUTSIDE = 0b00000100000,
+      BIND_FLAGS_NONE = 0b00001000000,
+      BIND_FLAGS_CLASS = 0b00010000000,
+      BIND_FLAGS_TS_ENUM = 0b00100000000,
+      BIND_FLAGS_TS_CONST_ENUM = 0b01000000000,
+      BIND_FLAGS_TS_EXPORT_ONLY = 0b10000000000;
+exports.BIND_FLAGS_TS_EXPORT_ONLY = BIND_FLAGS_TS_EXPORT_ONLY;
+exports.BIND_FLAGS_TS_CONST_ENUM = BIND_FLAGS_TS_CONST_ENUM;
+exports.BIND_FLAGS_TS_ENUM = BIND_FLAGS_TS_ENUM;
+exports.BIND_FLAGS_CLASS = BIND_FLAGS_CLASS;
+exports.BIND_FLAGS_NONE = BIND_FLAGS_NONE;
+exports.BIND_SCOPE_OUTSIDE = BIND_SCOPE_OUTSIDE;
+exports.BIND_SCOPE_FUNCTION = BIND_SCOPE_FUNCTION;
+exports.BIND_SCOPE_LEXICAL = BIND_SCOPE_LEXICAL;
+exports.BIND_SCOPE_VAR = BIND_SCOPE_VAR;
+exports.BIND_KIND_TYPE = BIND_KIND_TYPE;
+exports.BIND_KIND_VALUE = BIND_KIND_VALUE;
+const BIND_CLASS = BIND_KIND_VALUE | BIND_KIND_TYPE | BIND_SCOPE_LEXICAL | BIND_FLAGS_CLASS,
+      BIND_LEXICAL = BIND_KIND_VALUE | 0 | BIND_SCOPE_LEXICAL | 0,
+      BIND_VAR = BIND_KIND_VALUE | 0 | BIND_SCOPE_VAR | 0,
+      BIND_FUNCTION = BIND_KIND_VALUE | 0 | BIND_SCOPE_FUNCTION | 0,
+      BIND_TS_INTERFACE = 0 | BIND_KIND_TYPE | 0 | BIND_FLAGS_CLASS,
+      BIND_TS_TYPE = 0 | BIND_KIND_TYPE | 0 | 0,
+      BIND_TS_ENUM = BIND_KIND_VALUE | BIND_KIND_TYPE | BIND_SCOPE_LEXICAL | BIND_FLAGS_TS_ENUM,
+      BIND_TS_AMBIENT = 0 | 0 | 0 | BIND_FLAGS_TS_EXPORT_ONLY,
+      BIND_NONE = 0 | 0 | 0 | BIND_FLAGS_NONE,
+      BIND_OUTSIDE = BIND_KIND_VALUE | 0 | 0 | BIND_FLAGS_NONE,
+      BIND_TS_CONST_ENUM = BIND_TS_ENUM | BIND_FLAGS_TS_CONST_ENUM,
+      BIND_TS_NAMESPACE = 0 | 0 | 0 | BIND_FLAGS_TS_EXPORT_ONLY;
+exports.BIND_TS_NAMESPACE = BIND_TS_NAMESPACE;
+exports.BIND_TS_CONST_ENUM = BIND_TS_CONST_ENUM;
+exports.BIND_OUTSIDE = BIND_OUTSIDE;
+exports.BIND_NONE = BIND_NONE;
+exports.BIND_TS_AMBIENT = BIND_TS_AMBIENT;
+exports.BIND_TS_ENUM = BIND_TS_ENUM;
+exports.BIND_TS_TYPE = BIND_TS_TYPE;
+exports.BIND_TS_INTERFACE = BIND_TS_INTERFACE;
+exports.BIND_FUNCTION = BIND_FUNCTION;
+exports.BIND_VAR = BIND_VAR;
+exports.BIND_LEXICAL = BIND_LEXICAL;
+exports.BIND_CLASS = BIND_CLASS;
+const CLASS_ELEMENT_FLAG_STATIC = 0b100,
+      CLASS_ELEMENT_KIND_GETTER = 0b010,
+      CLASS_ELEMENT_KIND_SETTER = 0b001,
+      CLASS_ELEMENT_KIND_ACCESSOR = CLASS_ELEMENT_KIND_GETTER | CLASS_ELEMENT_KIND_SETTER;
+exports.CLASS_ELEMENT_KIND_ACCESSOR = CLASS_ELEMENT_KIND_ACCESSOR;
+exports.CLASS_ELEMENT_KIND_SETTER = CLASS_ELEMENT_KIND_SETTER;
+exports.CLASS_ELEMENT_KIND_GETTER = CLASS_ELEMENT_KIND_GETTER;
+exports.CLASS_ELEMENT_FLAG_STATIC = CLASS_ELEMENT_FLAG_STATIC;
+const CLASS_ELEMENT_STATIC_GETTER = CLASS_ELEMENT_KIND_GETTER | CLASS_ELEMENT_FLAG_STATIC,
+      CLASS_ELEMENT_STATIC_SETTER = CLASS_ELEMENT_KIND_SETTER | CLASS_ELEMENT_FLAG_STATIC,
+      CLASS_ELEMENT_INSTANCE_GETTER = CLASS_ELEMENT_KIND_GETTER,
+      CLASS_ELEMENT_INSTANCE_SETTER = CLASS_ELEMENT_KIND_SETTER,
+      CLASS_ELEMENT_OTHER = 0;
+exports.CLASS_ELEMENT_OTHER = CLASS_ELEMENT_OTHER;
+exports.CLASS_ELEMENT_INSTANCE_SETTER = CLASS_ELEMENT_INSTANCE_SETTER;
+exports.CLASS_ELEMENT_INSTANCE_GETTER = CLASS_ELEMENT_INSTANCE_GETTER;
+exports.CLASS_ELEMENT_STATIC_SETTER = CLASS_ELEMENT_STATIC_SETTER;
+exports.CLASS_ELEMENT_STATIC_GETTER = CLASS_ELEMENT_STATIC_GETTER;

Nodejs/node_modules/@babel/parser/lib/util/whitespace.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isNewLine = isNewLine;
+exports.isWhitespace = isWhitespace;
+exports.skipWhiteSpace = exports.lineBreakG = exports.lineBreak = void 0;
+const lineBreak = /\r\n?|[\n\u2028\u2029]/;
+exports.lineBreak = lineBreak;
+const lineBreakG = new RegExp(lineBreak.source, "g");
+exports.lineBreakG = lineBreakG;
+
+function isNewLine(code) {
+  switch (code) {
+    case 10:
+    case 13:
+    case 8232:
+    case 8233:
+      return true;
+
+    default:
+      return false;
+  }
+}
+
+const skipWhiteSpace = /(?:\s|\/\/.*|\/\*[^]*?\*\/)*/g;
+exports.skipWhiteSpace = skipWhiteSpace;
+
+function isWhitespace(code) {
+  switch (code) {
+    case 0x0009:
+    case 0x000b:
+    case 0x000c:
+    case 32:
+    case 160:
+    case 5760:
+    case 0x2000:
+    case 0x2001:
+    case 0x2002:
+    case 0x2003:
+    case 0x2004:
+    case 0x2005:
+    case 0x2006:
+    case 0x2007:
+    case 0x2008:
+    case 0x2009:
+    case 0x200a:
+    case 0x202f:
+    case 0x205f:
+    case 0x3000:
+    case 0xfeff:
+      return true;
+
+    default:
+      return false;
+  }
+}

Nodejs/node_modules/@babel/parser/package.json

@@ -0,0 +1,72 @@
+{
+  "_from": "@babel/parser@^7.7.5",
+  "_id": "@babel/parser@7.8.6",
+  "_inBundle": false,
+  "_integrity": "sha512-trGNYSfwq5s0SgM1BMEB8hX3NDmO7EP2wsDGDexiaKMB92BaRpS+qZfpkMqUBhcsOTBwNy9B/jieo4ad/t/z2g==",
+  "_location": "/@babel/parser",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "@babel/parser@^7.7.5",
+    "name": "@babel/parser",
+    "escapedName": "@babel%2fparser",
+    "scope": "@babel",
+    "rawSpec": "^7.7.5",
+    "saveSpec": null,
+    "fetchSpec": "^7.7.5"
+  },
+  "_requiredBy": [
+    "/pkg"
+  ],
+  "_resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.8.6.tgz",
+  "_shasum": "ba5c9910cddb77685a008e3c587af8d27b67962c",
+  "_spec": "@babel/parser@^7.7.5",
+  "_where": "/home/miti99/Dropbox/Workspace/FBcount/Nodejs/node_modules/pkg",
+  "author": {
+    "name": "Sebastian McKenzie",
+    "email": "sebmck@gmail.com"
+  },
+  "bin": {
+    "parser": "bin/babel-parser.js"
+  },
+  "bundleDependencies": false,
+  "deprecated": false,
+  "description": "A JavaScript parser",
+  "devDependencies": {
+    "@babel/code-frame": "^7.8.3",
+    "@babel/helper-fixtures": "^7.8.6",
+    "charcodes": "^0.2.0",
+    "unicode-12.0.0": "^0.7.9"
+  },
+  "engines": {
+    "node": ">=6.0.0"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "typings"
+  ],
+  "gitHead": "750d3dde3bd2d390819820fd22c05441da78751b",
+  "homepage": "https://babeljs.io/",
+  "keywords": [
+    "babel",
+    "javascript",
+    "parser",
+    "tc39",
+    "ecmascript",
+    "@babel/parser"
+  ],
+  "license": "MIT",
+  "main": "lib/index.js",
+  "name": "@babel/parser",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel/tree/master/packages/babel-parser"
+  },
+  "types": "typings/babel-parser.d.ts",
+  "version": "7.8.6"
+}

Nodejs/node_modules/@babel/parser/typings/babel-parser.d.ts

@@ -0,0 +1,146 @@
+// Type definitions for @babel/parser
+// Project: https://github.com/babel/babel/tree/master/packages/babel-parser
+// Definitions by: Troy Gerwien <https://github.com/yortus>
+//                 Marvin Hagemeister <https://github.com/marvinhagemeister>
+//                 Avi Vahl <https://github.com/AviVahl>
+// TypeScript Version: 2.9
+
+/**
+ * Parse the provided code as an entire ECMAScript program.
+ */
+export function parse(input: string, options?: ParserOptions): import('@babel/types').File;
+
+/**
+ * Parse the provided code as a single expression.
+ */
+export function parseExpression(input: string, options?: ParserOptions): import('@babel/types').Expression;
+
+export interface ParserOptions {
+    /**
+     * By default, import and export declarations can only appear at a program's top level.
+     * Setting this option to true allows them anywhere where a statement is allowed.
+     */
+    allowImportExportEverywhere?: boolean;
+
+    /**
+     * By default, await use is not allowed outside of an async function.
+     * Set this to true to accept such code.
+     */
+    allowAwaitOutsideFunction?: boolean;
+
+    /**
+     * By default, a return statement at the top level raises an error.
+     * Set this to true to accept such code.
+     */
+    allowReturnOutsideFunction?: boolean;
+
+    allowSuperOutsideMethod?: boolean;
+
+    /**
+     * By default, exported identifiers must refer to a declared variable.
+     * Set this to true to allow export statements to reference undeclared variables.
+     */
+    allowUndeclaredExports?: boolean;
+
+    /**
+     * Indicate the mode the code should be parsed in.
+     * Can be one of "script", "module", or "unambiguous". Defaults to "script".
+     * "unambiguous" will make @babel/parser attempt to guess, based on the presence
+     * of ES6 import or export statements.
+     * Files with ES6 imports and exports are considered "module" and are otherwise "script".
+     */
+    sourceType?: 'script' | 'module' | 'unambiguous';
+
+    /**
+     * Correlate output AST nodes with their source filename.
+     * Useful when generating code and source maps from the ASTs of multiple input files.
+     */
+    sourceFilename?: string;
+
+    /**
+     * By default, the first line of code parsed is treated as line 1.
+     * You can provide a line number to alternatively start with.
+     * Useful for integration with other source tools.
+     */
+    startLine?: number;
+
+    /**
+     * Array containing the plugins that you want to enable.
+     */
+    plugins?: ParserPlugin[];
+
+    /**
+     * Should the parser work in strict mode.
+     * Defaults to true if sourceType === 'module'. Otherwise, false.
+     */
+    strictMode?: boolean;
+
+    /**
+     * Adds a ranges property to each node: [node.start, node.end]
+     */
+    ranges?: boolean;
+
+    /**
+     * Adds all parsed tokens to a tokens property on the File node.
+     */
+    tokens?: boolean;
+
+    /**
+     * By default, the parser adds information about parentheses by setting
+     * `extra.parenthesized` to `true` as needed.
+     * When this option is `true` the parser creates `ParenthesizedExpression`
+     * AST nodes instead of using the `extra` property.
+     */
+    createParenthesizedExpressions?: boolean;
+}
+
+export type ParserPlugin =
+    'asyncGenerators' |
+    'bigInt' |
+    'classPrivateMethods' |
+    'classPrivateProperties' |
+    'classProperties' |
+    'decorators' |
+    'decorators-legacy' |
+    'doExpressions' |
+    'dynamicImport' |
+    'estree' |
+    'exportDefaultFrom' |
+    'exportNamespaceFrom' | // deprecated
+    'flow' |
+    'flowComments' |
+    'functionBind' |
+    'functionSent' |
+    'importMeta' |
+    'jsx' |
+    'logicalAssignment' |
+    'nullishCoalescingOperator' |
+    'numericSeparator' |
+    'objectRestSpread' |
+    'optionalCatchBinding' |
+    'optionalChaining' |
+    'partialApplication' |
+    'pipelineOperator' |
+    'placeholders' |
+    'throwExpressions' |
+    'topLevelAwait' |
+    'typescript' |
+    'v8intrinsic' |
+    ParserPluginWithOptions;
+
+export type ParserPluginWithOptions =
+    ['decorators', DecoratorsPluginOptions] |
+    ['pipelineOperator', PipelineOperatorPluginOptions] |
+    ['flow', FlowPluginOptions];
+
+export interface DecoratorsPluginOptions {
+    decoratorsBeforeExport?: boolean;
+}
+
+export interface PipelineOperatorPluginOptions {
+    proposal: 'minimal' | 'smart';
+}
+
+export interface FlowPluginOptions {
+    all?: boolean;
+}

Nodejs/node_modules/@babel/runtime/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie and other 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.

Nodejs/node_modules/@babel/runtime/README.md

@@ -0,0 +1,19 @@
+# @babel/runtime
+
+> babel's modular runtime helpers
+
+See our website [@babel/runtime](https://babeljs.io/docs/en/next/babel-runtime.html) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save @babel/runtime
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/runtime 
+```

Nodejs/node_modules/@babel/runtime/helpers/AsyncGenerator.js

@@ -0,0 +1,100 @@
+var AwaitValue = require("./AwaitValue");
+
+function AsyncGenerator(gen) {
+  var front, back;
+
+  function send(key, arg) {
+    return new Promise(function (resolve, reject) {
+      var request = {
+        key: key,
+        arg: arg,
+        resolve: resolve,
+        reject: reject,
+        next: null
+      };
+
+      if (back) {
+        back = back.next = request;
+      } else {
+        front = back = request;
+        resume(key, arg);
+      }
+    });
+  }
+
+  function resume(key, arg) {
+    try {
+      var result = gen[key](arg);
+      var value = result.value;
+      var wrappedAwait = value instanceof AwaitValue;
+      Promise.resolve(wrappedAwait ? value.wrapped : value).then(function (arg) {
+        if (wrappedAwait) {
+          resume(key === "return" ? "return" : "next", arg);
+          return;
+        }
+
+        settle(result.done ? "return" : "normal", arg);
+      }, function (err) {
+        resume("throw", err);
+      });
+    } catch (err) {
+      settle("throw", err);
+    }
+  }
+
+  function settle(type, value) {
+    switch (type) {
+      case "return":
+        front.resolve({
+          value: value,
+          done: true
+        });
+        break;
+
+      case "throw":
+        front.reject(value);
+        break;
+
+      default:
+        front.resolve({
+          value: value,
+          done: false
+        });
+        break;
+    }
+
+    front = front.next;
+
+    if (front) {
+      resume(front.key, front.arg);
+    } else {
+      back = null;
+    }
+  }
+
+  this._invoke = send;
+
+  if (typeof gen["return"] !== "function") {
+    this["return"] = undefined;
+  }
+}
+
+if (typeof Symbol === "function" && Symbol.asyncIterator) {
+  AsyncGenerator.prototype[Symbol.asyncIterator] = function () {
+    return this;
+  };
+}
+
+AsyncGenerator.prototype.next = function (arg) {
+  return this._invoke("next", arg);
+};
+
+AsyncGenerator.prototype["throw"] = function (arg) {
+  return this._invoke("throw", arg);
+};
+
+AsyncGenerator.prototype["return"] = function (arg) {
+  return this._invoke("return", arg);
+};
+
+module.exports = AsyncGenerator;

Nodejs/node_modules/@babel/runtime/helpers/AwaitValue.js

@@ -0,0 +1,5 @@
+function _AwaitValue(value) {
+  this.wrapped = value;
+}
+
+module.exports = _AwaitValue;

Nodejs/node_modules/@babel/runtime/helpers/applyDecoratedDescriptor.js

@@ -0,0 +1,30 @@
+function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) {
+  var desc = {};
+  Object.keys(descriptor).forEach(function (key) {
+    desc[key] = descriptor[key];
+  });
+  desc.enumerable = !!desc.enumerable;
+  desc.configurable = !!desc.configurable;
+
+  if ('value' in desc || desc.initializer) {
+    desc.writable = true;
+  }
+
+  desc = decorators.slice().reverse().reduce(function (desc, decorator) {
+    return decorator(target, property, desc) || desc;
+  }, desc);
+
+  if (context && desc.initializer !== void 0) {
+    desc.value = desc.initializer ? desc.initializer.call(context) : void 0;
+    desc.initializer = undefined;
+  }
+
+  if (desc.initializer === void 0) {
+    Object.defineProperty(target, property, desc);
+    desc = null;
+  }
+
+  return desc;
+}
+
+module.exports = _applyDecoratedDescriptor;

Nodejs/node_modules/@babel/runtime/helpers/arrayWithHoles.js

@@ -0,0 +1,5 @@
+function _arrayWithHoles(arr) {
+  if (Array.isArray(arr)) return arr;
+}
+
+module.exports = _arrayWithHoles;

Nodejs/node_modules/@babel/runtime/helpers/arrayWithoutHoles.js

@@ -0,0 +1,11 @@
+function _arrayWithoutHoles(arr) {
+  if (Array.isArray(arr)) {
+    for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) {
+      arr2[i] = arr[i];
+    }
+
+    return arr2;
+  }
+}
+
+module.exports = _arrayWithoutHoles;

Nodejs/node_modules/@babel/runtime/helpers/assertThisInitialized.js

@@ -0,0 +1,9 @@
+function _assertThisInitialized(self) {
+  if (self === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+
+  return self;
+}
+
+module.exports = _assertThisInitialized;

Nodejs/node_modules/@babel/runtime/helpers/asyncGeneratorDelegate.js

@@ -0,0 +1,58 @@
+function _asyncGeneratorDelegate(inner, awaitWrap) {
+  var iter = {},
+      waiting = false;
+
+  function pump(key, value) {
+    waiting = true;
+    value = new Promise(function (resolve) {
+      resolve(inner[key](value));
+    });
+    return {
+      done: false,
+      value: awaitWrap(value)
+    };
+  }
+
+  ;
+
+  if (typeof Symbol === "function" && Symbol.iterator) {
+    iter[Symbol.iterator] = function () {
+      return this;
+    };
+  }
+
+  iter.next = function (value) {
+    if (waiting) {
+      waiting = false;
+      return value;
+    }
+
+    return pump("next", value);
+  };
+
+  if (typeof inner["throw"] === "function") {
+    iter["throw"] = function (value) {
+      if (waiting) {
+        waiting = false;
+        throw value;
+      }
+
+      return pump("throw", value);
+    };
+  }
+
+  if (typeof inner["return"] === "function") {
+    iter["return"] = function (value) {
+      if (waiting) {
+        waiting = false;
+        return value;
+      }
+
+      return pump("return", value);
+    };
+  }
+
+  return iter;
+}
+
+module.exports = _asyncGeneratorDelegate;

Nodejs/node_modules/@babel/runtime/helpers/asyncIterator.js

@@ -0,0 +1,19 @@
+function _asyncIterator(iterable) {
+  var method;
+
+  if (typeof Symbol !== "undefined") {
+    if (Symbol.asyncIterator) {
+      method = iterable[Symbol.asyncIterator];
+      if (method != null) return method.call(iterable);
+    }
+
+    if (Symbol.iterator) {
+      method = iterable[Symbol.iterator];
+      if (method != null) return method.call(iterable);
+    }
+  }
+
+  throw new TypeError("Object is not async iterable");
+}
+
+module.exports = _asyncIterator;

Nodejs/node_modules/@babel/runtime/helpers/asyncToGenerator.js

@@ -0,0 +1,37 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+  try {
+    var info = gen[key](arg);
+    var value = info.value;
+  } catch (error) {
+    reject(error);
+    return;
+  }
+
+  if (info.done) {
+    resolve(value);
+  } else {
+    Promise.resolve(value).then(_next, _throw);
+  }
+}
+
+function _asyncToGenerator(fn) {
+  return function () {
+    var self = this,
+        args = arguments;
+    return new Promise(function (resolve, reject) {
+      var gen = fn.apply(self, args);
+
+      function _next(value) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+      }
+
+      function _throw(err) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+      }
+
+      _next(undefined);
+    });
+  };
+}
+
+module.exports = _asyncToGenerator;

Nodejs/node_modules/@babel/runtime/helpers/awaitAsyncGenerator.js

@@ -0,0 +1,7 @@
+var AwaitValue = require("./AwaitValue");
+
+function _awaitAsyncGenerator(value) {
+  return new AwaitValue(value);
+}
+
+module.exports = _awaitAsyncGenerator;

Nodejs/node_modules/@babel/runtime/helpers/classCallCheck.js

@@ -0,0 +1,7 @@
+function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+
+module.exports = _classCallCheck;

Nodejs/node_modules/@babel/runtime/helpers/classNameTDZError.js

@@ -0,0 +1,5 @@
+function _classNameTDZError(name) {
+  throw new Error("Class \"" + name + "\" cannot be referenced in computed property keys.");
+}
+
+module.exports = _classNameTDZError;

Nodejs/node_modules/@babel/runtime/helpers/classPrivateFieldDestructureSet.js

@@ -0,0 +1,28 @@
+function _classPrivateFieldDestructureSet(receiver, privateMap) {
+  if (!privateMap.has(receiver)) {
+    throw new TypeError("attempted to set private field on non-instance");
+  }
+
+  var descriptor = privateMap.get(receiver);
+
+  if (descriptor.set) {
+    if (!("__destrObj" in descriptor)) {
+      descriptor.__destrObj = {
+        set value(v) {
+          descriptor.set.call(receiver, v);
+        }
+
+      };
+    }
+
+    return descriptor.__destrObj;
+  } else {
+    if (!descriptor.writable) {
+      throw new TypeError("attempted to set read only private field");
+    }
+
+    return descriptor;
+  }
+}
+
+module.exports = _classPrivateFieldDestructureSet;

Nodejs/node_modules/@babel/runtime/helpers/classPrivateFieldGet.js

@@ -0,0 +1,15 @@
+function _classPrivateFieldGet(receiver, privateMap) {
+  var descriptor = privateMap.get(receiver);
+
+  if (!descriptor) {
+    throw new TypeError("attempted to get private field on non-instance");
+  }
+
+  if (descriptor.get) {
+    return descriptor.get.call(receiver);
+  }
+
+  return descriptor.value;
+}
+
+module.exports = _classPrivateFieldGet;

Nodejs/node_modules/@babel/runtime/helpers/classPrivateFieldLooseBase.js

@@ -0,0 +1,9 @@
+function _classPrivateFieldBase(receiver, privateKey) {
+  if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) {
+    throw new TypeError("attempted to use private field on non-instance");
+  }
+
+  return receiver;
+}
+
+module.exports = _classPrivateFieldBase;

Nodejs/node_modules/@babel/runtime/helpers/classPrivateFieldLooseKey.js

@@ -0,0 +1,7 @@
+var id = 0;
+
+function _classPrivateFieldKey(name) {
+  return "__private_" + id++ + "_" + name;
+}
+
+module.exports = _classPrivateFieldKey;

Nodejs/node_modules/@babel/runtime/helpers/classPrivateFieldSet.js

@@ -0,0 +1,21 @@
+function _classPrivateFieldSet(receiver, privateMap, value) {
+  var descriptor = privateMap.get(receiver);
+
+  if (!descriptor) {
+    throw new TypeError("attempted to set private field on non-instance");
+  }
+
+  if (descriptor.set) {
+    descriptor.set.call(receiver, value);
+  } else {
+    if (!descriptor.writable) {
+      throw new TypeError("attempted to set read only private field");
+    }
+
+    descriptor.value = value;
+  }
+
+  return value;
+}
+
+module.exports = _classPrivateFieldSet;

Nodejs/node_modules/@babel/runtime/helpers/classPrivateMethodGet.js

@@ -0,0 +1,9 @@
+function _classPrivateMethodGet(receiver, privateSet, fn) {
+  if (!privateSet.has(receiver)) {
+    throw new TypeError("attempted to get private field on non-instance");
+  }
+
+  return fn;
+}
+
+module.exports = _classPrivateMethodGet;

Nodejs/node_modules/@babel/runtime/helpers/classPrivateMethodSet.js

@@ -0,0 +1,5 @@
+function _classPrivateMethodSet() {
+  throw new TypeError("attempted to reassign private method");
+}
+
+module.exports = _classPrivateMethodSet;

Nodejs/node_modules/@babel/runtime/helpers/classStaticPrivateFieldSpecGet.js

@@ -0,0 +1,13 @@
+function _classStaticPrivateFieldSpecGet(receiver, classConstructor, descriptor) {
+  if (receiver !== classConstructor) {
+    throw new TypeError("Private static access of wrong provenance");
+  }
+
+  if (descriptor.get) {
+    return descriptor.get.call(receiver);
+  }
+
+  return descriptor.value;
+}
+
+module.exports = _classStaticPrivateFieldSpecGet;

Nodejs/node_modules/@babel/runtime/helpers/classStaticPrivateFieldSpecSet.js

@@ -0,0 +1,19 @@
+function _classStaticPrivateFieldSpecSet(receiver, classConstructor, descriptor, value) {
+  if (receiver !== classConstructor) {
+    throw new TypeError("Private static access of wrong provenance");
+  }
+
+  if (descriptor.set) {
+    descriptor.set.call(receiver, value);
+  } else {
+    if (!descriptor.writable) {
+      throw new TypeError("attempted to set read only private field");
+    }
+
+    descriptor.value = value;
+  }
+
+  return value;
+}
+
+module.exports = _classStaticPrivateFieldSpecSet;

Nodejs/node_modules/@babel/runtime/helpers/classStaticPrivateMethodGet.js

@@ -0,0 +1,9 @@
+function _classStaticPrivateMethodGet(receiver, classConstructor, method) {
+  if (receiver !== classConstructor) {
+    throw new TypeError("Private static access of wrong provenance");
+  }
+
+  return method;
+}
+
+module.exports = _classStaticPrivateMethodGet;

Nodejs/node_modules/@babel/runtime/helpers/classStaticPrivateMethodSet.js

@@ -0,0 +1,5 @@
+function _classStaticPrivateMethodSet() {
+  throw new TypeError("attempted to set read only static private field");
+}
+
+module.exports = _classStaticPrivateMethodSet;

Nodejs/node_modules/@babel/runtime/helpers/construct.js

@@ -0,0 +1,33 @@
+var setPrototypeOf = require("./setPrototypeOf");
+
+function isNativeReflectConstruct() {
+  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+  if (Reflect.construct.sham) return false;
+  if (typeof Proxy === "function") return true;
+
+  try {
+    Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+function _construct(Parent, args, Class) {
+  if (isNativeReflectConstruct()) {
+    module.exports = _construct = Reflect.construct;
+  } else {
+    module.exports = _construct = function _construct(Parent, args, Class) {
+      var a = [null];
+      a.push.apply(a, args);
+      var Constructor = Function.bind.apply(Parent, a);
+      var instance = new Constructor();
+      if (Class) setPrototypeOf(instance, Class.prototype);
+      return instance;
+    };
+  }
+
+  return _construct.apply(null, arguments);
+}
+
+module.exports = _construct;

Nodejs/node_modules/@babel/runtime/helpers/createClass.js

@@ -0,0 +1,17 @@
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, descriptor.key, descriptor);
+  }
+}
+
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  return Constructor;
+}
+
+module.exports = _createClass;

Nodejs/node_modules/@babel/runtime/helpers/decorate.js

@@ -0,0 +1,400 @@
+var toArray = require("./toArray");
+
+var toPropertyKey = require("./toPropertyKey");
+
+function _decorate(decorators, factory, superClass, mixins) {
+  var api = _getDecoratorsApi();
+
+  if (mixins) {
+    for (var i = 0; i < mixins.length; i++) {
+      api = mixins[i](api);
+    }
+  }
+
+  var r = factory(function initialize(O) {
+    api.initializeInstanceElements(O, decorated.elements);
+  }, superClass);
+  var decorated = api.decorateClass(_coalesceClassElements(r.d.map(_createElementDescriptor)), decorators);
+  api.initializeClassElements(r.F, decorated.elements);
+  return api.runClassFinishers(r.F, decorated.finishers);
+}
+
+function _getDecoratorsApi() {
+  _getDecoratorsApi = function _getDecoratorsApi() {
+    return api;
+  };
+
+  var api = {
+    elementsDefinitionOrder: [["method"], ["field"]],
+    initializeInstanceElements: function initializeInstanceElements(O, elements) {
+      ["method", "field"].forEach(function (kind) {
+        elements.forEach(function (element) {
+          if (element.kind === kind && element.placement === "own") {
+            this.defineClassElement(O, element);
+          }
+        }, this);
+      }, this);
+    },
+    initializeClassElements: function initializeClassElements(F, elements) {
+      var proto = F.prototype;
+      ["method", "field"].forEach(function (kind) {
+        elements.forEach(function (element) {
+          var placement = element.placement;
+
+          if (element.kind === kind && (placement === "static" || placement === "prototype")) {
+            var receiver = placement === "static" ? F : proto;
+            this.defineClassElement(receiver, element);
+          }
+        }, this);
+      }, this);
+    },
+    defineClassElement: function defineClassElement(receiver, element) {
+      var descriptor = element.descriptor;
+
+      if (element.kind === "field") {
+        var initializer = element.initializer;
+        descriptor = {
+          enumerable: descriptor.enumerable,
+          writable: descriptor.writable,
+          configurable: descriptor.configurable,
+          value: initializer === void 0 ? void 0 : initializer.call(receiver)
+        };
+      }
+
+      Object.defineProperty(receiver, element.key, descriptor);
+    },
+    decorateClass: function decorateClass(elements, decorators) {
+      var newElements = [];
+      var finishers = [];
+      var placements = {
+        "static": [],
+        prototype: [],
+        own: []
+      };
+      elements.forEach(function (element) {
+        this.addElementPlacement(element, placements);
+      }, this);
+      elements.forEach(function (element) {
+        if (!_hasDecorators(element)) return newElements.push(element);
+        var elementFinishersExtras = this.decorateElement(element, placements);
+        newElements.push(elementFinishersExtras.element);
+        newElements.push.apply(newElements, elementFinishersExtras.extras);
+        finishers.push.apply(finishers, elementFinishersExtras.finishers);
+      }, this);
+
+      if (!decorators) {
+        return {
+          elements: newElements,
+          finishers: finishers
+        };
+      }
+
+      var result = this.decorateConstructor(newElements, decorators);
+      finishers.push.apply(finishers, result.finishers);
+      result.finishers = finishers;
+      return result;
+    },
+    addElementPlacement: function addElementPlacement(element, placements, silent) {
+      var keys = placements[element.placement];
+
+      if (!silent && keys.indexOf(element.key) !== -1) {
+        throw new TypeError("Duplicated element (" + element.key + ")");
+      }
+
+      keys.push(element.key);
+    },
+    decorateElement: function decorateElement(element, placements) {
+      var extras = [];
+      var finishers = [];
+
+      for (var decorators = element.decorators, i = decorators.length - 1; i >= 0; i--) {
+        var keys = placements[element.placement];
+        keys.splice(keys.indexOf(element.key), 1);
+        var elementObject = this.fromElementDescriptor(element);
+        var elementFinisherExtras = this.toElementFinisherExtras((0, decorators[i])(elementObject) || elementObject);
+        element = elementFinisherExtras.element;
+        this.addElementPlacement(element, placements);
+
+        if (elementFinisherExtras.finisher) {
+          finishers.push(elementFinisherExtras.finisher);
+        }
+
+        var newExtras = elementFinisherExtras.extras;
+
+        if (newExtras) {
+          for (var j = 0; j < newExtras.length; j++) {
+            this.addElementPlacement(newExtras[j], placements);
+          }
+
+          extras.push.apply(extras, newExtras);
+        }
+      }
+
+      return {
+        element: element,
+        finishers: finishers,
+        extras: extras
+      };
+    },
+    decorateConstructor: function decorateConstructor(elements, decorators) {
+      var finishers = [];
+
+      for (var i = decorators.length - 1; i >= 0; i--) {
+        var obj = this.fromClassDescriptor(elements);
+        var elementsAndFinisher = this.toClassDescriptor((0, decorators[i])(obj) || obj);
+
+        if (elementsAndFinisher.finisher !== undefined) {
+          finishers.push(elementsAndFinisher.finisher);
+        }
+
+        if (elementsAndFinisher.elements !== undefined) {
+          elements = elementsAndFinisher.elements;
+
+          for (var j = 0; j < elements.length - 1; j++) {
+            for (var k = j + 1; k < elements.length; k++) {
+              if (elements[j].key === elements[k].key && elements[j].placement === elements[k].placement) {
+                throw new TypeError("Duplicated element (" + elements[j].key + ")");
+              }
+            }
+          }
+        }
+      }
+
+      return {
+        elements: elements,
+        finishers: finishers
+      };
+    },
+    fromElementDescriptor: function fromElementDescriptor(element) {
+      var obj = {
+        kind: element.kind,
+        key: element.key,
+        placement: element.placement,
+        descriptor: element.descriptor
+      };
+      var desc = {
+        value: "Descriptor",
+        configurable: true
+      };
+      Object.defineProperty(obj, Symbol.toStringTag, desc);
+      if (element.kind === "field") obj.initializer = element.initializer;
+      return obj;
+    },
+    toElementDescriptors: function toElementDescriptors(elementObjects) {
+      if (elementObjects === undefined) return;
+      return toArray(elementObjects).map(function (elementObject) {
+        var element = this.toElementDescriptor(elementObject);
+        this.disallowProperty(elementObject, "finisher", "An element descriptor");
+        this.disallowProperty(elementObject, "extras", "An element descriptor");
+        return element;
+      }, this);
+    },
+    toElementDescriptor: function toElementDescriptor(elementObject) {
+      var kind = String(elementObject.kind);
+
+      if (kind !== "method" && kind !== "field") {
+        throw new TypeError('An element descriptor\'s .kind property must be either "method" or' + ' "field", but a decorator created an element descriptor with' + ' .kind "' + kind + '"');
+      }
+
+      var key = toPropertyKey(elementObject.key);
+      var placement = String(elementObject.placement);
+
+      if (placement !== "static" && placement !== "prototype" && placement !== "own") {
+        throw new TypeError('An element descriptor\'s .placement property must be one of "static",' + ' "prototype" or "own", but a decorator created an element descriptor' + ' with .placement "' + placement + '"');
+      }
+
+      var descriptor = elementObject.descriptor;
+      this.disallowProperty(elementObject, "elements", "An element descriptor");
+      var element = {
+        kind: kind,
+        key: key,
+        placement: placement,
+        descriptor: Object.assign({}, descriptor)
+      };
+
+      if (kind !== "field") {
+        this.disallowProperty(elementObject, "initializer", "A method descriptor");
+      } else {
+        this.disallowProperty(descriptor, "get", "The property descriptor of a field descriptor");
+        this.disallowProperty(descriptor, "set", "The property descriptor of a field descriptor");
+        this.disallowProperty(descriptor, "value", "The property descriptor of a field descriptor");
+        element.initializer = elementObject.initializer;
+      }
+
+      return element;
+    },
+    toElementFinisherExtras: function toElementFinisherExtras(elementObject) {
+      var element = this.toElementDescriptor(elementObject);
+
+      var finisher = _optionalCallableProperty(elementObject, "finisher");
+
+      var extras = this.toElementDescriptors(elementObject.extras);
+      return {
+        element: element,
+        finisher: finisher,
+        extras: extras
+      };
+    },
+    fromClassDescriptor: function fromClassDescriptor(elements) {
+      var obj = {
+        kind: "class",
+        elements: elements.map(this.fromElementDescriptor, this)
+      };
+      var desc = {
+        value: "Descriptor",
+        configurable: true
+      };
+      Object.defineProperty(obj, Symbol.toStringTag, desc);
+      return obj;
+    },
+    toClassDescriptor: function toClassDescriptor(obj) {
+      var kind = String(obj.kind);
+
+      if (kind !== "class") {
+        throw new TypeError('A class descriptor\'s .kind property must be "class", but a decorator' + ' created a class descriptor with .kind "' + kind + '"');
+      }
+
+      this.disallowProperty(obj, "key", "A class descriptor");
+      this.disallowProperty(obj, "placement", "A class descriptor");
+      this.disallowProperty(obj, "descriptor", "A class descriptor");
+      this.disallowProperty(obj, "initializer", "A class descriptor");
+      this.disallowProperty(obj, "extras", "A class descriptor");
+
+      var finisher = _optionalCallableProperty(obj, "finisher");
+
+      var elements = this.toElementDescriptors(obj.elements);
+      return {
+        elements: elements,
+        finisher: finisher
+      };
+    },
+    runClassFinishers: function runClassFinishers(constructor, finishers) {
+      for (var i = 0; i < finishers.length; i++) {
+        var newConstructor = (0, finishers[i])(constructor);
+
+        if (newConstructor !== undefined) {
+          if (typeof newConstructor !== "function") {
+            throw new TypeError("Finishers must return a constructor.");
+          }
+
+          constructor = newConstructor;
+        }
+      }
+
+      return constructor;
+    },
+    disallowProperty: function disallowProperty(obj, name, objectType) {
+      if (obj[name] !== undefined) {
+        throw new TypeError(objectType + " can't have a ." + name + " property.");
+      }
+    }
+  };
+  return api;
+}
+
+function _createElementDescriptor(def) {
+  var key = toPropertyKey(def.key);
+  var descriptor;
+
+  if (def.kind === "method") {
+    descriptor = {
+      value: def.value,
+      writable: true,
+      configurable: true,
+      enumerable: false
+    };
+  } else if (def.kind === "get") {
+    descriptor = {
+      get: def.value,
+      configurable: true,
+      enumerable: false
+    };
+  } else if (def.kind === "set") {
+    descriptor = {
+      set: def.value,
+      configurable: true,
+      enumerable: false
+    };
+  } else if (def.kind === "field") {
+    descriptor = {
+      configurable: true,
+      writable: true,
+      enumerable: true
+    };
+  }
+
+  var element = {
+    kind: def.kind === "field" ? "field" : "method",
+    key: key,
+    placement: def["static"] ? "static" : def.kind === "field" ? "own" : "prototype",
+    descriptor: descriptor
+  };
+  if (def.decorators) element.decorators = def.decorators;
+  if (def.kind === "field") element.initializer = def.value;
+  return element;
+}
+
+function _coalesceGetterSetter(element, other) {
+  if (element.descriptor.get !== undefined) {
+    other.descriptor.get = element.descriptor.get;
+  } else {
+    other.descriptor.set = element.descriptor.set;
+  }
+}
+
+function _coalesceClassElements(elements) {
+  var newElements = [];
+
+  var isSameElement = function isSameElement(other) {
+    return other.kind === "method" && other.key === element.key && other.placement === element.placement;
+  };
+
+  for (var i = 0; i < elements.length; i++) {
+    var element = elements[i];
+    var other;
+
+    if (element.kind === "method" && (other = newElements.find(isSameElement))) {
+      if (_isDataDescriptor(element.descriptor) || _isDataDescriptor(other.descriptor)) {
+        if (_hasDecorators(element) || _hasDecorators(other)) {
+          throw new ReferenceError("Duplicated methods (" + element.key + ") can't be decorated.");
+        }
+
+        other.descriptor = element.descriptor;
+      } else {
+        if (_hasDecorators(element)) {
+          if (_hasDecorators(other)) {
+            throw new ReferenceError("Decorators can't be placed on different accessors with for " + "the same property (" + element.key + ").");
+          }
+
+          other.decorators = element.decorators;
+        }
+
+        _coalesceGetterSetter(element, other);
+      }
+    } else {
+      newElements.push(element);
+    }
+  }
+
+  return newElements;
+}
+
+function _hasDecorators(element) {
+  return element.decorators && element.decorators.length;
+}
+
+function _isDataDescriptor(desc) {
+  return desc !== undefined && !(desc.value === undefined && desc.writable === undefined);
+}
+
+function _optionalCallableProperty(obj, name) {
+  var value = obj[name];
+
+  if (value !== undefined && typeof value !== "function") {
+    throw new TypeError("Expected '" + name + "' to be a function");
+  }
+
+  return value;
+}
+
+module.exports = _decorate;

Nodejs/node_modules/@babel/runtime/helpers/defaults.js

@@ -0,0 +1,16 @@
+function _defaults(obj, defaults) {
+  var keys = Object.getOwnPropertyNames(defaults);
+
+  for (var i = 0; i < keys.length; i++) {
+    var key = keys[i];
+    var value = Object.getOwnPropertyDescriptor(defaults, key);
+
+    if (value && value.configurable && obj[key] === undefined) {
+      Object.defineProperty(obj, key, value);
+    }
+  }
+
+  return obj;
+}
+
+module.exports = _defaults;

Nodejs/node_modules/@babel/runtime/helpers/defineEnumerableProperties.js

@@ -0,0 +1,24 @@
+function _defineEnumerableProperties(obj, descs) {
+  for (var key in descs) {
+    var desc = descs[key];
+    desc.configurable = desc.enumerable = true;
+    if ("value" in desc) desc.writable = true;
+    Object.defineProperty(obj, key, desc);
+  }
+
+  if (Object.getOwnPropertySymbols) {
+    var objectSymbols = Object.getOwnPropertySymbols(descs);
+
+    for (var i = 0; i < objectSymbols.length; i++) {
+      var sym = objectSymbols[i];
+      var desc = descs[sym];
+      desc.configurable = desc.enumerable = true;
+      if ("value" in desc) desc.writable = true;
+      Object.defineProperty(obj, sym, desc);
+    }
+  }
+
+  return obj;
+}
+
+module.exports = _defineEnumerableProperties;

Nodejs/node_modules/@babel/runtime/helpers/defineProperty.js

@@ -0,0 +1,16 @@
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+
+  return obj;
+}
+
+module.exports = _defineProperty;

Nodejs/node_modules/@babel/runtime/helpers/esm/AsyncGenerator.js

@@ -0,0 +1,97 @@
+import AwaitValue from "./AwaitValue";
+export default function AsyncGenerator(gen) {
+  var front, back;
+
+  function send(key, arg) {
+    return new Promise(function (resolve, reject) {
+      var request = {
+        key: key,
+        arg: arg,
+        resolve: resolve,
+        reject: reject,
+        next: null
+      };
+
+      if (back) {
+        back = back.next = request;
+      } else {
+        front = back = request;
+        resume(key, arg);
+      }
+    });
+  }
+
+  function resume(key, arg) {
+    try {
+      var result = gen[key](arg);
+      var value = result.value;
+      var wrappedAwait = value instanceof AwaitValue;
+      Promise.resolve(wrappedAwait ? value.wrapped : value).then(function (arg) {
+        if (wrappedAwait) {
+          resume(key === "return" ? "return" : "next", arg);
+          return;
+        }
+
+        settle(result.done ? "return" : "normal", arg);
+      }, function (err) {
+        resume("throw", err);
+      });
+    } catch (err) {
+      settle("throw", err);
+    }
+  }
+
+  function settle(type, value) {
+    switch (type) {
+      case "return":
+        front.resolve({
+          value: value,
+          done: true
+        });
+        break;
+
+      case "throw":
+        front.reject(value);
+        break;
+
+      default:
+        front.resolve({
+          value: value,
+          done: false
+        });
+        break;
+    }
+
+    front = front.next;
+
+    if (front) {
+      resume(front.key, front.arg);
+    } else {
+      back = null;
+    }
+  }
+
+  this._invoke = send;
+
+  if (typeof gen["return"] !== "function") {
+    this["return"] = undefined;
+  }
+}
+
+if (typeof Symbol === "function" && Symbol.asyncIterator) {
+  AsyncGenerator.prototype[Symbol.asyncIterator] = function () {
+    return this;
+  };
+}
+
+AsyncGenerator.prototype.next = function (arg) {
+  return this._invoke("next", arg);
+};
+
+AsyncGenerator.prototype["throw"] = function (arg) {
+  return this._invoke("throw", arg);
+};
+
+AsyncGenerator.prototype["return"] = function (arg) {
+  return this._invoke("return", arg);
+};

Nodejs/node_modules/@babel/runtime/helpers/esm/AwaitValue.js

@@ -0,0 +1,3 @@
+export default function _AwaitValue(value) {
+  this.wrapped = value;
+}

Nodejs/node_modules/@babel/runtime/helpers/esm/applyDecoratedDescriptor.js

@@ -0,0 +1,28 @@
+export default function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) {
+  var desc = {};
+  Object.keys(descriptor).forEach(function (key) {
+    desc[key] = descriptor[key];
+  });
+  desc.enumerable = !!desc.enumerable;
+  desc.configurable = !!desc.configurable;
+
+  if ('value' in desc || desc.initializer) {
+    desc.writable = true;
+  }
+
+  desc = decorators.slice().reverse().reduce(function (desc, decorator) {
+    return decorator(target, property, desc) || desc;
+  }, desc);
+
+  if (context && desc.initializer !== void 0) {
+    desc.value = desc.initializer ? desc.initializer.call(context) : void 0;
+    desc.initializer = undefined;
+  }
+
+  if (desc.initializer === void 0) {
+    Object.defineProperty(target, property, desc);
+    desc = null;
+  }
+
+  return desc;
+}

Nodejs/node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js

@@ -0,0 +1,3 @@
+export default function _arrayWithHoles(arr) {
+  if (Array.isArray(arr)) return arr;
+}

Nodejs/node_modules/@babel/runtime/helpers/esm/arrayWithoutHoles.js

@@ -0,0 +1,9 @@
+export default function _arrayWithoutHoles(arr) {
+  if (Array.isArray(arr)) {
+    for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) {
+      arr2[i] = arr[i];
+    }
+
+    return arr2;
+  }
+}

Nodejs/node_modules/@babel/runtime/helpers/esm/assertThisInitialized.js

@@ -0,0 +1,7 @@
+export default function _assertThisInitialized(self) {
+  if (self === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+
+  return self;
+}

Nodejs/node_modules/@babel/runtime/helpers/esm/asyncGeneratorDelegate.js

@@ -0,0 +1,56 @@
+export default function _asyncGeneratorDelegate(inner, awaitWrap) {
+  var iter = {},
+      waiting = false;
+
+  function pump(key, value) {
+    waiting = true;
+    value = new Promise(function (resolve) {
+      resolve(inner[key](value));
+    });
+    return {
+      done: false,
+      value: awaitWrap(value)
+    };
+  }
+
+  ;
+
+  if (typeof Symbol === "function" && Symbol.iterator) {
+    iter[Symbol.iterator] = function () {
+      return this;
+    };
+  }
+
+  iter.next = function (value) {
+    if (waiting) {
+      waiting = false;
+      return value;
+    }
+
+    return pump("next", value);
+  };
+
+  if (typeof inner["throw"] === "function") {
+    iter["throw"] = function (value) {
+      if (waiting) {
+        waiting = false;
+        throw value;
+      }
+
+      return pump("throw", value);
+    };
+  }
+
+  if (typeof inner["return"] === "function") {
+    iter["return"] = function (value) {
+      if (waiting) {
+        waiting = false;
+        return value;
+      }
+
+      return pump("return", value);
+    };
+  }
+
+  return iter;
+}

Nodejs/node_modules/@babel/runtime/helpers/esm/asyncIterator.js

@@ -0,0 +1,17 @@
+export default function _asyncIterator(iterable) {
+  var method;
+
+  if (typeof Symbol !== "undefined") {
+    if (Symbol.asyncIterator) {
+      method = iterable[Symbol.asyncIterator];
+      if (method != null) return method.call(iterable);
+    }
+
+    if (Symbol.iterator) {
+      method = iterable[Symbol.iterator];
+      if (method != null) return method.call(iterable);
+    }
+  }
+
+  throw new TypeError("Object is not async iterable");
+}

Nodejs/node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js

@@ -0,0 +1,35 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+  try {
+    var info = gen[key](arg);
+    var value = info.value;
+  } catch (error) {
+    reject(error);
+    return;
+  }
+
+  if (info.done) {
+    resolve(value);
+  } else {
+    Promise.resolve(value).then(_next, _throw);
+  }
+}
+
+export default function _asyncToGenerator(fn) {
+  return function () {
+    var self = this,
+        args = arguments;
+    return new Promise(function (resolve, reject) {
+      var gen = fn.apply(self, args);
+
+      function _next(value) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+      }
+
+      function _throw(err) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+      }
+
+      _next(undefined);
+    });
+  };
+}

Nodejs/node_modules/@babel/runtime/helpers/esm/awaitAsyncGenerator.js

@@ -0,0 +1,4 @@
+import AwaitValue from "./AwaitValue";
+export default function _awaitAsyncGenerator(value) {
+  return new AwaitValue(value);
+}

Nodejs/node_modules/@babel/runtime/helpers/esm/classCallCheck.js

@@ -0,0 +1,5 @@
+export default function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}

Nodejs/node_modules/@babel/runtime/helpers/esm/classNameTDZError.js

@@ -0,0 +1,3 @@
+export default function _classNameTDZError(name) {
+  throw new Error("Class \"" + name + "\" cannot be referenced in computed property keys.");
+}

Nodejs/node_modules/@babel/runtime/helpers/esm/classPrivateFieldDestructureSet.js

@@ -0,0 +1,26 @@
+export default function _classPrivateFieldDestructureSet(receiver, privateMap) {
+  if (!privateMap.has(receiver)) {
+    throw new TypeError("attempted to set private field on non-instance");
+  }
+
+  var descriptor = privateMap.get(receiver);
+
+  if (descriptor.set) {
+    if (!("__destrObj" in descriptor)) {
+      descriptor.__destrObj = {
+        set value(v) {
+          descriptor.set.call(receiver, v);
+        }
+
+      };
+    }
+
+    return descriptor.__destrObj;
+  } else {
+    if (!descriptor.writable) {
+      throw new TypeError("attempted to set read only private field");
+    }
+
+    return descriptor;
+  }
+}

Nodejs/node_modules/@babel/runtime/helpers/esm/classPrivateFieldGet.js

@@ -0,0 +1,13 @@
+export default function _classPrivateFieldGet(receiver, privateMap) {
+  var descriptor = privateMap.get(receiver);
+
+  if (!descriptor) {
+    throw new TypeError("attempted to get private field on non-instance");
+  }
+
+  if (descriptor.get) {
+    return descriptor.get.call(receiver);
+  }
+
+  return descriptor.value;
+}