Fixed #1 - Fixed the whatsnew-** script for loading release notes into builds

Added test to ensure that release notes are parsed properly
Updated to latest dependencies to fix security vulnerability
Updated GH Actions Workflow to run test before updating tag
Updated README.md to reflect proper whatsnew documentation.

node_modules/@babel/parser/CHANGELOG.md

@@ -2,7 +2,7 @@
 
 > **Tags:**
 > - :boom:       [Breaking Change]
-> - :eyeglasses: [Spec Compliancy]
+> - :eyeglasses: [Spec Compliance]
 > - :rocket:     [New Feature]
 > - :bug:        [Bug Fix]
 > - :memo:       [Documentation]
@@ -56,7 +56,7 @@ See the [Babel Changelog](https://github.com/babel/babel/blob/master/CHANGELOG.m
 
 ## 7.0.0-beta.7 (2017-03-22)
 
-### Spec Compliancy
+### Spec Compliance
 * Remove babylon plugin for template revision since it's stage-4 (#426) (Henry Zhu)
 
 ### Bug Fix
@@ -200,7 +200,7 @@ declare module "C" {
 }
 ```
 
-### :eyeglasses: Spec Compliancy
+### :eyeglasses: Spec Compliance
 
 Forbid semicolons after decorators in classes ([#352](https://github.com/babel/babylon/pull/352)) (Kevin Gibbons)
 
@@ -305,7 +305,7 @@ AST spec: fix casing of `RegExpLiteral` ([#318](https://github.com/babel/babylon
 
 ## 6.15.0 (2017-01-10)
 
-### :eyeglasses: Spec Compliancy
+### :eyeglasses: Spec Compliance
 
 Add support for Flow shorthand import type ([#267](https://github.com/babel/babylon/pull/267)) (Jeff Morrison)
 
@@ -411,7 +411,7 @@ Will include all parser plugins instead of specifying each one individually. Use
 
 ## 6.14.0 (2016-11-16)
 
-### :eyeglasses: Spec Compliancy
+### :eyeglasses: Spec Compliance
 
 Throw error for reserved words `enum` and `await` ([#195](https://github.com/babel/babylon/pull/195)) (Kai Cataldo)
 
@@ -491,7 +491,7 @@ With that test case, there was a ~95ms savings by removing the need for node to
 
 ## v6.13.0 (2016-10-21)
 
-### :eyeglasses: Spec Compliancy
+### :eyeglasses: Spec Compliance
 
 Property variance type annotations for Flow plugin ([#161](https://github.com/babel/babylon/pull/161)) (Sam Goldman)
 
@@ -549,7 +549,7 @@ Fixes two tests that are failing after the merge of #172 ([#177](https://github.
 
 ## v6.12.0 (2016-10-14)
 
-### :eyeglasses: Spec Compliancy
+### :eyeglasses: Spec Compliance
 
 Implement import() syntax ([#163](https://github.com/babel/babylon/pull/163)) (Jordan Gensler)
 
@@ -643,7 +643,7 @@ export const { foo: [ ,, qux7 ] } = bar;
 
 ## v6.11.5 (2016-10-12)
 
-### :eyeglasses: Spec Compliancy
+### :eyeglasses: Spec Compliance
 
 Fix: Check for duplicate named exports in exported destructuring assignments ([#144](https://github.com/babel/babylon/pull/144)) (Kai Cataldo)
 
@@ -689,7 +689,7 @@ Temporary rollback for erroring on trailing comma with spread (#154) (Henry Zhu)
 
 ## v6.11.3 (2016-10-01)
 
-### :eyeglasses: Spec Compliancy
+### :eyeglasses: Spec Compliance
 
 Add static errors for object rest (#149) ([@danez](https://github.com/danez))
 
@@ -782,7 +782,7 @@ export toString from './toString';
 
 ## 6.11.0 (2016-09-22)
 
-### Spec Compliancy (will break CI)
+### Spec Compliance (will break CI)
 
 - Disallow duplicate named exports ([#107](https://github.com/babel/babylon/pull/107)) @kaicataldo
 
@@ -862,9 +862,9 @@ for (+i in {});
 
 ## 6.10.0 (2016-09-19)
 
-> We plan to include some spec compliancy bugs in patch versions. An example was the multiple default exports issue.
+> We plan to include some spec compliance bugs in patch versions. An example was the multiple default exports issue.
 
-### Spec Compliancy
+### Spec Compliance
 
 * Implement ES2016 check for simple parameter list in strict mode ([#106](https://github.com/babel/babylon/pull/106)) (Timothy Gu)
 
@@ -1023,7 +1023,7 @@ declare module "foo" {
 - The existential type `*` is not a valid type parameter.
 - The existential type `*` is a primary type
 
-### Spec Compliancy
+### Spec Compliance
 - The param list for type parameter declarations now consists of `TypeParameter` nodes
 - New `TypeParameter` AST Node (replaces using the `Identifier` node before)
 

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

@@ -7,10 +7,9 @@ var fs = require("fs");
 var filename = process.argv[2];
 if (!filename) {
   console.error("no filename specified");
-  process.exit(0);
+} else {
+  var file = fs.readFileSync(filename, "utf8");
+  var ast = parser.parse(file);
+
+  console.log(JSON.stringify(ast, null, "  "));
 }
-
-var file = fs.readFileSync(filename, "utf8");
-var ast = parser.parse(file);
-
-console.log(JSON.stringify(ast, null, "  "));

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;
+}

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;

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;

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

@@ -0,0 +1,68 @@
+"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"));
+
+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.classScope = new _classScope.default(this.raise.bind(this));
+    this.plugins = pluginsMap(this.options.plugins);
+    this.filename = options.sourceFilename;
+  }
+
+  getScopeHandler() {
+    return _scope.default;
+  }
+
+  parse() {
+    let scopeFlags = _scopeflags.SCOPE_PROGRAM;
+
+    if (this.hasPlugin("topLevelAwait") && this.inModule) {
+      scopeFlags |= _scopeflags.SCOPE_ASYNC;
+    }
+
+    this.scope.enter(scopeFlags);
+    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;
+}

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;

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;

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;

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;

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;

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;

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;

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;

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;

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;

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;

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.scope.inGenerator) {
+      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;
+};

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;

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;

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;

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);
+}

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);
+}

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

@@ -0,0 +1,183 @@
+"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 inGenerator() {
+    return (this.currentVarScope().flags & _scopeflags.SCOPE_GENERATOR) > 0;
+  }
+
+  get inAsync() {
+    for (let i = this.scopeStack.length - 1;; i--) {
+      const scope = this.scopeStack[i];
+      const isVarScope = scope.flags & _scopeflags.SCOPE_VAR;
+      const isClassScope = scope.flags & _scopeflags.SCOPE_CLASS;
+
+      if (isClassScope && !isVarScope) {
+        return false;
+      } else if (isVarScope) {
+        return (scope.flags & _scopeflags.SCOPE_ASYNC) > 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;

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

@@ -0,0 +1,100 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.functionFlags = functionFlags;
+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_GENERATOR = exports.SCOPE_ASYNC = exports.SCOPE_FUNCTION = exports.SCOPE_PROGRAM = exports.SCOPE_OTHER = void 0;
+const SCOPE_OTHER = 0b0000000000,
+      SCOPE_PROGRAM = 0b0000000001,
+      SCOPE_FUNCTION = 0b0000000010,
+      SCOPE_ASYNC = 0b0000000100,
+      SCOPE_GENERATOR = 0b0000001000,
+      SCOPE_ARROW = 0b0000010000,
+      SCOPE_SIMPLE_CATCH = 0b0000100000,
+      SCOPE_SUPER = 0b0001000000,
+      SCOPE_DIRECT_SUPER = 0b0010000000,
+      SCOPE_CLASS = 0b0100000000,
+      SCOPE_TS_MODULE = 0b1000000000,
+      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_GENERATOR = SCOPE_GENERATOR;
+exports.SCOPE_ASYNC = SCOPE_ASYNC;
+exports.SCOPE_FUNCTION = SCOPE_FUNCTION;
+exports.SCOPE_PROGRAM = SCOPE_PROGRAM;
+exports.SCOPE_OTHER = SCOPE_OTHER;
+
+function functionFlags(isAsync, isGenerator) {
+  return SCOPE_FUNCTION | (isAsync ? SCOPE_ASYNC : 0) | (isGenerator ? SCOPE_GENERATOR : 0);
+}
+
+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;

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;
+  }
+}

node_modules/@babel/parser/package.json

@@ -1,27 +1,20 @@
 {
-  "_args": [
-    [
-      "@babel/parser@7.5.5",
-      "/Users/drew.heavner/Documents/Github/upload-google-play"
-    ]
-  ],
-  "_development": true,
-  "_from": "@babel/parser@7.5.5",
-  "_id": "@babel/parser@7.5.5",
+  "_from": "@babel/parser@^7.8.4",
+  "_id": "@babel/parser@7.8.4",
   "_inBundle": false,
-  "_integrity": "sha512-E5BN68cqR7dhKan1SfqgPGhQ178bkVKpXTPEXnFJBrEt8/DKRZlybmy+IgYLTeN7tp1R5Ccmbm2rBk17sHYU3g==",
+  "_integrity": "sha512-0fKu/QqildpXmPVaRBoXOlyBb3MC+J0A66x97qEfLOMkn3u6nfY5esWogQwi/K0BjASYy4DbnsEWnpNL6qT5Mw==",
   "_location": "/@babel/parser",
   "_phantomChildren": {},
   "_requested": {
-    "type": "version",
+    "type": "range",
     "registry": true,
-    "raw": "@babel/parser@7.5.5",
+    "raw": "@babel/parser@^7.8.4",
     "name": "@babel/parser",
     "escapedName": "@babel%2fparser",
     "scope": "@babel",
-    "rawSpec": "7.5.5",
+    "rawSpec": "^7.8.4",
     "saveSpec": null,
-    "fetchSpec": "7.5.5"
+    "fetchSpec": "^7.8.4"
   },
   "_requiredBy": [
     "/@babel/core",
@@ -31,20 +24,23 @@
     "/@types/babel__template",
     "/istanbul-lib-instrument"
   ],
-  "_resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.5.5.tgz",
-  "_spec": "7.5.5",
-  "_where": "/Users/drew.heavner/Documents/Github/upload-google-play",
+  "_resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.8.4.tgz",
+  "_shasum": "d1dbe64691d60358a974295fa53da074dd2ce8e8",
+  "_spec": "@babel/parser@^7.8.4",
+  "_where": "/Users/drew.heavner/Documents/Github/upload-google-play/node_modules/@babel/core",
   "author": {
     "name": "Sebastian McKenzie",
     "email": "sebmck@gmail.com"
   },
   "bin": {
-    "parser": "./bin/babel-parser.js"
+    "parser": "bin/babel-parser.js"
   },
+  "bundleDependencies": false,
+  "deprecated": false,
   "description": "A JavaScript parser",
   "devDependencies": {
-    "@babel/code-frame": "^7.5.5",
-    "@babel/helper-fixtures": "^7.5.5",
+    "@babel/code-frame": "^7.8.3",
+    "@babel/helper-fixtures": "^7.8.3",
     "charcodes": "^0.2.0",
     "unicode-12.0.0": "^0.7.9"
   },
@@ -56,7 +52,7 @@
     "lib",
     "typings"
   ],
-  "gitHead": "0407f034f09381b95e9cabefbf6b176c76485a43",
+  "gitHead": "5c2e6bc07fed3d28801d93168622c99ae622653a",
   "homepage": "https://babeljs.io/",
   "keywords": [
     "babel",
@@ -70,12 +66,12 @@
   "main": "lib/index.js",
   "name": "@babel/parser",
   "publishConfig": {
-    "tag": "next"
+    "access": "public"
   },
   "repository": {
     "type": "git",
     "url": "https://github.com/babel/babel/tree/master/packages/babel-parser"
   },
   "types": "typings/babel-parser.d.ts",
-  "version": "7.5.5"
+  "version": "7.8.4"
 }