Update node_modules

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,364 @@
+"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");
+
+const unwrapParenthesizedExpression = node => {
+  return node.type === "ParenthesizedExpression" ? unwrapParenthesizedExpression(node.expression) : node;
+};
+
+class LValParser extends _node.NodeUtils {
+  toAssignable(node, isBinding, contextDescription) {
+    var _node$extra3;
+
+    if (node) {
+      var _node$extra;
+
+      if (this.options.createParenthesizedExpressions && node.type === "ParenthesizedExpression" || ((_node$extra = node.extra) == null ? void 0 : _node$extra.parenthesized)) {
+        const 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, isBinding, 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, isBinding, contextDescription);
+          break;
+
+        case "SpreadElement":
+          {
+            this.checkToRestConversion(node);
+            node.type = "RestElement";
+            const arg = node.argument;
+            this.toAssignable(arg, isBinding, contextDescription);
+            break;
+          }
+
+        case "ArrayExpression":
+          node.type = "ArrayPattern";
+          this.toAssignableList(node.elements, isBinding, contextDescription, (_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, isBinding, contextDescription);
+          break;
+
+        case "ParenthesizedExpression":
+          node.expression = this.toAssignable(node.expression, isBinding, contextDescription);
+          break;
+
+        case "MemberExpression":
+          if (!isBinding) break;
+
+        default:
+      }
+    }
+
+    return node;
+  }
+
+  toAssignableObjectExpressionProp(prop, isBinding, 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, isBinding, "object destructuring pattern");
+    }
+  }
+
+  toAssignableList(exprList, isBinding, contextDescription, 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, isBinding, contextDescription);
+
+        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, isBinding, contextDescription);
+
+        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(refShorthandDefaultPos, refNeedsArrowPos) {
+    const node = this.startNode();
+    this.next();
+    node.argument = this.parseMaybeAssign(false, refShorthandDefaultPos, 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,219 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+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;
+    }
+  }
+
+}
+
+exports.default = UtilParser;

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,265 @@
+"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) {
+    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 && !protoRef.start) {
+        protoRef.start = key.start;
+      }
+
+      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(refShorthandDefaultPos) {
+    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(refShorthandDefaultPos);
+    }
+  }
+
+  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, refShorthandDefaultPos) {
+    const node = super.parseObjectProperty(prop, startPos, startLoc, isPattern, refShorthandDefaultPos);
+
+    if (node) {
+      node.kind = "init";
+      node.type = "Property";
+    }
+
+    return node;
+  }
+
+  toAssignable(node, isBinding, contextDescription) {
+    if (isSimpleProperty(node)) {
+      this.toAssignable(node.value, isBinding, contextDescription);
+      return node;
+    }
+
+    return super.toAssignable(node, isBinding, contextDescription);
+  }
+
+  toAssignableObjectExpressionProp(prop, isBinding, 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, isBinding, 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(refShortHandDefaultPos) {
+    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(refShortHandDefaultPos);
+    }
+  }
+
+  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.tokens = [];
+    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 = [];
+  }
+
+  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("||", 2),
+  logicalAND: createBinop("&&", 3),
+  bitwiseOR: createBinop("|", 4),
+  bitwiseXOR: createBinop("^", 5),
+  bitwiseAND: createBinop("&", 6),
+  equality: createBinop("==/!=/===/!==", 7),
+  relational: createBinop("</>/<=/>=", 8),
+  bitShift: createBinop("<</>>/>>>", 9),
+  plusMin: new TokenType("+/-", {
+    beforeExpr,
+    binop: 10,
+    prefix,
+    startsExpr
+  }),
+  modulo: new TokenType("%", {
+    beforeExpr,
+    binop: 11,
+    startsExpr
+  }),
+  star: createBinop("*", 11),
+  slash: createBinop("/", 11),
+  exponent: new TokenType("**", {
+    beforeExpr,
+    binop: 12,
+    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: 8
+  }),
+  _instanceof: createKeyword("instanceof", {
+    beforeExpr,
+    binop: 8
+  }),
+  _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;
+  }
+}