docs：更新文档

node_modules/@babel/parser/LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2012-2014 by various contributors (see AUTHORS)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

node_modules/@babel/parser/README.md

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

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

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

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,205 @@
+"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 {
+        const firstTrailingCommentIndex = trailingComments.findIndex(comment => comment.end >= node.end);
+
+        if (firstTrailingCommentIndex > 0) {
+          node.innerComments = trailingComments.slice(0, firstTrailingCommentIndex);
+          node.trailingComments = trailingComments.slice(firstTrailingCommentIndex);
+        } else {
+          node.trailingComments = trailingComments;
+        }
+      }
+    }
+
+    stack.push(node);
+  }
+
+}
+
+exports.default = CommentsParser;

node_modules/@babel/parser/lib/parser/error-message.js

@@ -0,0 +1,154 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ErrorMessages = void 0;
+const ErrorMessages = Object.freeze({
+  AccessorIsGenerator: "A %0ter cannot be a generator",
+  ArgumentsInClass: "'arguments' is only allowed in functions and class methods",
+  AsyncFunctionInSingleStatementContext: "Async functions can only be declared at the top level or inside a block",
+  AwaitBindingIdentifier: "Can not use 'await' as identifier inside an async function",
+  AwaitExpressionFormalParameter: "await is not allowed in async function parameters",
+  AwaitNotInAsyncContext: "'await' is only allowed within async functions and at the top levels of modules",
+  AwaitNotInAsyncFunction: "'await' is only allowed within async functions",
+  BadGetterArity: "getter must not have any formal parameters",
+  BadSetterArity: "setter must have exactly one formal parameter",
+  BadSetterRestParameter: "setter function argument must not be a rest parameter",
+  ConstructorClassField: "Classes may not have a field named 'constructor'",
+  ConstructorClassPrivateField: "Classes may not have a private field named '#constructor'",
+  ConstructorIsAccessor: "Class constructor may not be an accessor",
+  ConstructorIsAsync: "Constructor can't be an async function",
+  ConstructorIsGenerator: "Constructor can't be a generator",
+  DeclarationMissingInitializer: "%0 require an initialization value",
+  DecoratorBeforeExport: "Decorators must be placed *before* the 'export' keyword. You can set the 'decoratorsBeforeExport' option to false to use the 'export @decorator class {}' syntax",
+  DecoratorConstructor: "Decorators can't be used with a constructor. Did you mean '@dec class { ... }'?",
+  DecoratorExportClass: "Using the export keyword between a decorator and a class is not allowed. Please use `export @dec class` instead.",
+  DecoratorSemicolon: "Decorators must not be followed by a semicolon",
+  DecoratorStaticBlock: "Decorators can't be used with a static block",
+  DeletePrivateField: "Deleting a private field is not allowed",
+  DestructureNamedImport: "ES2015 named imports do not destructure. Use another statement for destructuring after the import.",
+  DuplicateConstructor: "Duplicate constructor in the same class",
+  DuplicateDefaultExport: "Only one default export allowed per module.",
+  DuplicateExport: "`%0` has already been exported. Exported identifiers must be unique.",
+  DuplicateProto: "Redefinition of __proto__ property",
+  DuplicateRegExpFlags: "Duplicate regular expression flag",
+  DuplicateStaticBlock: "Duplicate static block in the same class",
+  ElementAfterRest: "Rest element must be last element",
+  EscapedCharNotAnIdentifier: "Invalid Unicode escape",
+  ExportBindingIsString: "A string literal cannot be used as an exported binding without `from`.\n- Did you mean `export { %0 as '%1' } from 'some-module'`?",
+  ExportDefaultFromAsIdentifier: "'from' is not allowed as an identifier after 'export default'",
+  ForInOfLoopInitializer: "%0 loop variable declaration may not have an initializer",
+  GeneratorInSingleStatementContext: "Generators can only be declared at the top level or inside a block",
+  IllegalBreakContinue: "Unsyntactic %0",
+  IllegalLanguageModeDirective: "Illegal 'use strict' directive in function with non-simple parameter list",
+  IllegalReturn: "'return' outside of function",
+  ImportBindingIsString: 'A string literal cannot be used as an imported binding.\n- Did you mean `import { "%0" as foo }`?',
+  ImportCallArgumentTrailingComma: "Trailing comma is disallowed inside import(...) arguments",
+  ImportCallArity: "import() requires exactly %0",
+  ImportCallNotNewExpression: "Cannot use new with import(...)",
+  ImportCallSpreadArgument: "... is not allowed in import()",
+  ImportMetaOutsideModule: `import.meta may appear only with 'sourceType: "module"'`,
+  ImportOutsideModule: `'import' and 'export' may appear only with 'sourceType: "module"'`,
+  InvalidBigIntLiteral: "Invalid BigIntLiteral",
+  InvalidCodePoint: "Code point out of bounds",
+  InvalidDecimal: "Invalid decimal",
+  InvalidDigit: "Expected number in radix %0",
+  InvalidEscapeSequence: "Bad character escape sequence",
+  InvalidEscapeSequenceTemplate: "Invalid escape sequence in template",
+  InvalidEscapedReservedWord: "Escape sequence in keyword %0",
+  InvalidIdentifier: "Invalid identifier %0",
+  InvalidLhs: "Invalid left-hand side in %0",
+  InvalidLhsBinding: "Binding invalid left-hand side in %0",
+  InvalidNumber: "Invalid number",
+  InvalidOrMissingExponent: "Floating-point numbers require a valid exponent after the 'e'",
+  InvalidOrUnexpectedToken: "Unexpected character '%0'",
+  InvalidParenthesizedAssignment: "Invalid parenthesized assignment pattern",
+  InvalidPrivateFieldResolution: "Private name #%0 is not defined",
+  InvalidPropertyBindingPattern: "Binding member expression",
+  InvalidRecordProperty: "Only properties and spread elements are allowed in record definitions",
+  InvalidRestAssignmentPattern: "Invalid rest operator's argument",
+  LabelRedeclaration: "Label '%0' is already declared",
+  LetInLexicalBinding: "'let' is not allowed to be used as a name in 'let' or 'const' declarations.",
+  LineTerminatorBeforeArrow: "No line break is allowed before '=>'",
+  MalformedRegExpFlags: "Invalid regular expression flag",
+  MissingClassName: "A class name is required",
+  MissingEqInAssignment: "Only '=' operator can be used for specifying default value.",
+  MissingUnicodeEscape: "Expecting Unicode escape sequence \\uXXXX",
+  MixingCoalesceWithLogical: "Nullish coalescing operator(??) requires parens when mixing with logical operators",
+  ModuleAttributeDifferentFromType: "The only accepted module attribute is `type`",
+  ModuleAttributeInvalidValue: "Only string literals are allowed as module attribute values",
+  ModuleAttributesWithDuplicateKeys: 'Duplicate key "%0" is not allowed in module attributes',
+  ModuleExportNameHasLoneSurrogate: "An export name cannot include a lone surrogate, found '\\u%0'",
+  ModuleExportUndefined: "Export '%0' is not defined",
+  MultipleDefaultsInSwitch: "Multiple default clauses",
+  NewlineAfterThrow: "Illegal newline after throw",
+  NoCatchOrFinally: "Missing catch or finally clause",
+  NumberIdentifier: "Identifier directly after number",
+  NumericSeparatorInEscapeSequence: "Numeric separators are not allowed inside unicode escape sequences or hex escape sequences",
+  ObsoleteAwaitStar: "await* has been removed from the async functions proposal. Use Promise.all() instead.",
+  OptionalChainingNoNew: "constructors in/after an Optional Chain are not allowed",
+  OptionalChainingNoTemplate: "Tagged Template Literals are not allowed in optionalChain",
+  ParamDupe: "Argument name clash",
+  PatternHasAccessor: "Object pattern can't contain getter or setter",
+  PatternHasMethod: "Object pattern can't contain methods",
+  PipelineBodyNoArrow: 'Unexpected arrow "=>" after pipeline body; arrow function in pipeline body must be parenthesized',
+  PipelineBodySequenceExpression: "Pipeline body may not be a comma-separated sequence expression",
+  PipelineHeadSequenceExpression: "Pipeline head should not be a comma-separated sequence expression",
+  PipelineTopicUnused: "Pipeline is in topic style but does not use topic reference",
+  PrimaryTopicNotAllowed: "Topic reference was used in a lexical context without topic binding",
+  PrimaryTopicRequiresSmartPipeline: "Primary Topic Reference found but pipelineOperator not passed 'smart' for 'proposal' option.",
+  PrivateInExpectedIn: "Private names are only allowed in property accesses (`obj.#%0`) or in `in` expressions (`#%0 in obj`)",
+  PrivateNameRedeclaration: "Duplicate private name #%0",
+  RecordExpressionBarIncorrectEndSyntaxType: "Record expressions ending with '|}' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'",
+  RecordExpressionBarIncorrectStartSyntaxType: "Record expressions starting with '{|' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'",
+  RecordExpressionHashIncorrectStartSyntaxType: "Record expressions starting with '#{' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'hash'",
+  RecordNoProto: "'__proto__' is not allowed in Record expressions",
+  RestTrailingComma: "Unexpected trailing comma after rest element",
+  SloppyFunction: "In non-strict mode code, functions can only be declared at top level, inside a block, or as the body of an if statement",
+  StaticPrototype: "Classes may not have static property named prototype",
+  StrictDelete: "Deleting local variable in strict mode",
+  StrictEvalArguments: "Assigning to '%0' in strict mode",
+  StrictEvalArgumentsBinding: "Binding '%0' in strict mode",
+  StrictFunction: "In strict mode code, functions can only be declared at top level or inside a block",
+  StrictNumericEscape: "The only valid numeric escape in strict mode is '\\0'",
+  StrictOctalLiteral: "Legacy octal literals are not allowed in strict mode",
+  StrictWith: "'with' in strict mode",
+  SuperNotAllowed: "super() is only valid inside a class constructor of a subclass. Maybe a typo in the method name ('constructor') or not extending another class?",
+  SuperPrivateField: "Private fields can't be accessed on super",
+  TrailingDecorator: "Decorators must be attached to a class element",
+  TupleExpressionBarIncorrectEndSyntaxType: "Tuple expressions ending with '|]' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'",
+  TupleExpressionBarIncorrectStartSyntaxType: "Tuple expressions starting with '[|' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'",
+  TupleExpressionHashIncorrectStartSyntaxType: "Tuple expressions starting with '#[' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'hash'",
+  UnexpectedArgumentPlaceholder: "Unexpected argument placeholder",
+  UnexpectedAwaitAfterPipelineBody: 'Unexpected "await" after pipeline body; await must have parentheses in minimal proposal',
+  UnexpectedDigitAfterHash: "Unexpected digit after hash token",
+  UnexpectedImportExport: "'import' and 'export' may only appear at the top level",
+  UnexpectedKeyword: "Unexpected keyword '%0'",
+  UnexpectedLeadingDecorator: "Leading decorators must be attached to a class declaration",
+  UnexpectedLexicalDeclaration: "Lexical declaration cannot appear in a single-statement context",
+  UnexpectedNewTarget: "new.target can only be used in functions",
+  UnexpectedNumericSeparator: "A numeric separator is only allowed between two digits",
+  UnexpectedPrivateField: "Private names can only be used as the name of a class element (i.e. class C { #p = 42; #m() {} } )\n or a property of member expression (i.e. this.#p).",
+  UnexpectedReservedWord: "Unexpected reserved word '%0'",
+  UnexpectedSuper: "super is only allowed in object methods and classes",
+  UnexpectedToken: "Unexpected token '%0'",
+  UnexpectedTokenUnaryExponentiation: "Illegal expression. Wrap left hand side or entire exponentiation in parentheses.",
+  UnsupportedBind: "Binding should be performed on object property.",
+  UnsupportedDecoratorExport: "A decorated export must export a class declaration",
+  UnsupportedDefaultExport: "Only expressions, functions or classes are allowed as the `default` export.",
+  UnsupportedImport: "import can only be used in import() or import.meta",
+  UnsupportedMetaProperty: "The only valid meta property for %0 is %0.%1",
+  UnsupportedParameterDecorator: "Decorators cannot be used to decorate parameters",
+  UnsupportedPropertyDecorator: "Decorators cannot be used to decorate object literal properties",
+  UnsupportedSuper: "super can only be used with function calls (i.e. super()) or in property accesses (i.e. super.prop or super[prop])",
+  UnterminatedComment: "Unterminated comment",
+  UnterminatedRegExp: "Unterminated regular expression",
+  UnterminatedString: "Unterminated string constant",
+  UnterminatedTemplate: "Unterminated template",
+  VarRedeclaration: "Identifier '%0' has already been declared",
+  YieldBindingIdentifier: "Can not use 'yield' as identifier inside a generator",
+  YieldInParameter: "Yield expression is not allowed in formal parameters",
+  ZeroDigitNumericSeparator: "Numeric separator can not be used after leading 0"
+});
+exports.ErrorMessages = ErrorMessages;

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

@@ -0,0 +1,56 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Errors", {
+  enumerable: true,
+  get: function () {
+    return _errorMessage.ErrorMessages;
+  }
+});
+exports.default = void 0;
+
+var _location = require("../util/location");
+
+var _comments = _interopRequireDefault(require("./comments"));
+
+var _errorMessage = require("./error-message.js");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class ParserError 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, errorTemplate, ...params) {
+    return this.raiseWithData(pos, undefined, errorTemplate, ...params);
+  }
+
+  raiseWithData(pos, data, errorTemplate, ...params) {
+    const loc = this.getLocationForPosition(pos);
+    const message = errorTemplate.replace(/%(\d+)/g, (_, i) => params[i]) + ` (${loc.line}:${loc.column})`;
+    return this._raise(Object.assign({
+      loc,
+      pos
+    }, data), message);
+  }
+
+  _raise(errorContext, message) {
+    const err = new SyntaxError(message);
+    Object.assign(err, errorContext);
+
+    if (this.options.errorRecovery) {
+      if (!this.isLookahead) this.state.errors.push(err);
+      return err;
+    } else {
+      throw err;
+    }
+  }
+
+}
+
+exports.default = ParserError;

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

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

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

@@ -0,0 +1,358 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _types = require("../tokenizer/types");
+
+var _identifier = require("../util/identifier");
+
+var _node = require("./node");
+
+var _scopeflags = require("../util/scopeflags");
+
+var _util = require("./util");
+
+var _error = require("./error");
+
+const unwrapParenthesizedExpression = node => {
+  return node.type === "ParenthesizedExpression" ? unwrapParenthesizedExpression(node.expression) : node;
+};
+
+class LValParser extends _node.NodeUtils {
+  toAssignable(node) {
+    let parenthesized = undefined;
+
+    if (node.type === "ParenthesizedExpression" || node.extra?.parenthesized) {
+      parenthesized = unwrapParenthesizedExpression(node);
+
+      if (parenthesized.type !== "Identifier" && parenthesized.type !== "MemberExpression") {
+        this.raise(node.start, _error.Errors.InvalidParenthesizedAssignment);
+      }
+    }
+
+    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++) {
+          const prop = node.properties[i];
+          const isLast = i === last;
+          this.toAssignableObjectExpressionProp(prop, isLast);
+
+          if (isLast && prop.type === "RestElement" && node.extra?.trailingComma) {
+            this.raiseRestNotLast(node.extra.trailingComma);
+          }
+        }
+
+        break;
+
+      case "ObjectProperty":
+        this.toAssignable(node.value);
+        break;
+
+      case "SpreadElement":
+        {
+          this.checkToRestConversion(node);
+          node.type = "RestElement";
+          const arg = node.argument;
+          this.toAssignable(arg);
+          break;
+        }
+
+      case "ArrayExpression":
+        node.type = "ArrayPattern";
+        this.toAssignableList(node.elements, node.extra?.trailingComma);
+        break;
+
+      case "AssignmentExpression":
+        if (node.operator !== "=") {
+          this.raise(node.left.end, _error.Errors.MissingEqInAssignment);
+        }
+
+        node.type = "AssignmentPattern";
+        delete node.operator;
+        this.toAssignable(node.left);
+        break;
+
+      case "ParenthesizedExpression":
+        this.toAssignable(parenthesized);
+        break;
+
+      default:
+    }
+
+    return node;
+  }
+
+  toAssignableObjectExpressionProp(prop, isLast) {
+    if (prop.type === "ObjectMethod") {
+      const error = prop.kind === "get" || prop.kind === "set" ? _error.Errors.PatternHasAccessor : _error.Errors.PatternHasMethod;
+      this.raise(prop.key.start, error);
+    } else if (prop.type === "SpreadElement" && !isLast) {
+      this.raiseRestNotLast(prop.start);
+    } else {
+      this.toAssignable(prop);
+    }
+  }
+
+  toAssignableList(exprList, trailingCommaPos) {
+    let end = exprList.length;
+
+    if (end) {
+      const last = exprList[end - 1];
+
+      if (last?.type === "RestElement") {
+        --end;
+      } else if (last?.type === "SpreadElement") {
+        last.type = "RestElement";
+        const arg = last.argument;
+        this.toAssignable(arg);
+
+        if (arg.type !== "Identifier" && arg.type !== "MemberExpression" && arg.type !== "ArrayPattern" && arg.type !== "ObjectPattern") {
+          this.unexpected(arg.start);
+        }
+
+        if (trailingCommaPos) {
+          this.raiseTrailingCommaAfterRest(trailingCommaPos);
+        }
+
+        --end;
+      }
+    }
+
+    for (let i = 0; i < end; i++) {
+      const elt = exprList[i];
+
+      if (elt) {
+        this.toAssignable(elt);
+
+        if (elt.type === "RestElement") {
+          this.raiseRestNotLast(elt.start);
+        }
+      }
+    }
+
+    return exprList;
+  }
+
+  toReferencedList(exprList, isParenthesizedExpr) {
+    return exprList;
+  }
+
+  toReferencedListDeep(exprList, isParenthesizedExpr) {
+    this.toReferencedList(exprList, isParenthesizedExpr);
+
+    for (let _i = 0; _i < exprList.length; _i++) {
+      const expr = exprList[_i];
+
+      if (expr?.type === "ArrayExpression") {
+        this.toReferencedListDeep(expr.elements);
+      }
+    }
+  }
+
+  parseSpread(refExpressionErrors, refNeedsArrowPos) {
+    const node = this.startNode();
+    this.next();
+    node.argument = this.parseMaybeAssignAllowIn(refExpressionErrors, undefined, refNeedsArrowPos);
+    return this.finishNode(node, "SpreadElement");
+  }
+
+  parseRestBinding() {
+    const node = this.startNode();
+    this.next();
+    node.argument = this.parseBindingAtom();
+    return this.finishNode(node, "RestElement");
+  }
+
+  parseBindingAtom() {
+    switch (this.state.type) {
+      case _types.types.bracketL:
+        {
+          const node = this.startNode();
+          this.next();
+          node.elements = this.parseBindingList(_types.types.bracketR, 93, true);
+          return this.finishNode(node, "ArrayPattern");
+        }
+
+      case _types.types.braceL:
+        return this.parseObjectLike(_types.types.braceR, 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, _error.Errors.UnsupportedParameterDecorator);
+        }
+
+        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.parseMaybeAssignAllowIn();
+    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 ? _error.Errors.StrictEvalArguments : _error.Errors.StrictEvalArgumentsBinding, expr.name);
+        }
+
+        if (checkClashes) {
+          const key = `_${expr.name}`;
+
+          if (checkClashes[key]) {
+            this.raise(expr.start, _error.Errors.ParamDupe);
+          } else {
+            checkClashes[key] = true;
+          }
+        }
+
+        if (disallowLetBinding && expr.name === "let") {
+          this.raise(expr.start, _error.Errors.LetInLexicalBinding);
+        }
+
+        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, _error.Errors.InvalidPropertyBindingPattern);
+        }
+
+        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:
+        {
+          this.raise(expr.start, bindingType === _scopeflags.BIND_NONE ? _error.Errors.InvalidLhs : _error.Errors.InvalidLhsBinding, contextDescription);
+        }
+    }
+  }
+
+  checkToRestConversion(node) {
+    if (node.argument.type !== "Identifier" && node.argument.type !== "MemberExpression") {
+      this.raise(node.argument.start, _error.Errors.InvalidRestAssignmentPattern);
+    }
+  }
+
+  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, _error.Errors.ElementAfterRest);
+  }
+
+  raiseTrailingCommaAfterRest(pos) {
+    this.raise(pos, _error.Errors.RestTrailingComma);
+  }
+
+}
+
+exports.default = LValParser;

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

@@ -0,0 +1,98 @@
+"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 = void 0;
+    this.start = void 0;
+    this.end = void 0;
+    this.loc = void 0;
+    this.range = void 0;
+    this.leadingComments = void 0;
+    this.trailingComments = void 0;
+    this.innerComments = void 0;
+    this.extra = void 0;
+    this.type = "";
+    this.start = pos;
+    this.end = 0;
+    this.loc = new _location.SourceLocation(loc);
+    if (parser?.options.ranges) this.range = [pos, 0];
+    if (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,206 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ExpressionErrors = exports.default = void 0;
+
+var _types = require("../tokenizer/types");
+
+var _tokenizer = _interopRequireDefault(require("../tokenizer"));
+
+var _state = _interopRequireDefault(require("../tokenizer/state"));
+
+var _whitespace = require("../util/whitespace");
+
+var _identifier = require("../util/identifier");
+
+var _error = require("./error");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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;
+  }
+
+  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.raiseWithData(pos != null ? pos : this.state.start, {
+        missingPlugin: [name]
+      }, `This experimental syntax requires enabling the parser plugin: '${name}'`);
+    }
+
+    return true;
+  }
+
+  expectOnePlugin(names, pos) {
+    if (!names.some(n => this.hasPlugin(n))) {
+      throw this.raiseWithData(pos != null ? pos : this.state.start, {
+        missingPlugin: names
+      }, `This experimental syntax requires enabling one of the following parser plugin(s): '${names.join(", ")}'`);
+    }
+  }
+
+  tryParse(fn, oldState = this.state.clone()) {
+    const abortSignal = {
+      node: null
+    };
+
+    try {
+      const node = fn((node = null) => {
+        abortSignal.node = node;
+        throw abortSignal;
+      });
+
+      if (this.state.errors.length > oldState.errors.length) {
+        const failState = this.state;
+        this.state = oldState;
+        return {
+          node,
+          error: failState.errors[oldState.errors.length],
+          thrown: false,
+          aborted: false,
+          failState
+        };
+      }
+
+      return {
+        node,
+        error: null,
+        thrown: false,
+        aborted: false,
+        failState: null
+      };
+    } catch (error) {
+      const failState = this.state;
+      this.state = oldState;
+
+      if (error instanceof SyntaxError) {
+        return {
+          node: null,
+          error,
+          thrown: true,
+          aborted: false,
+          failState
+        };
+      }
+
+      if (error === abortSignal) {
+        return {
+          node: abortSignal.node,
+          error: null,
+          thrown: false,
+          aborted: true,
+          failState
+        };
+      }
+
+      throw error;
+    }
+  }
+
+  checkExpressionErrors(refExpressionErrors, andThrow) {
+    if (!refExpressionErrors) return false;
+    const {
+      shorthandAssign,
+      doubleProto
+    } = refExpressionErrors;
+    if (!andThrow) return shorthandAssign >= 0 || doubleProto >= 0;
+
+    if (shorthandAssign >= 0) {
+      this.unexpected(shorthandAssign);
+    }
+
+    if (doubleProto >= 0) {
+      this.raise(doubleProto, _error.Errors.DuplicateProto);
+    }
+  }
+
+  isLiteralPropertyName() {
+    return this.match(_types.types.name) || !!this.state.type.keyword || this.match(_types.types.string) || this.match(_types.types.num) || this.match(_types.types.bigint) || this.match(_types.types.decimal);
+  }
+
+}
+
+exports.default = UtilParser;
+
+class ExpressionErrors {
+  constructor() {
+    this.shorthandAssign = -1;
+    this.doubleProto = -1;
+  }
+
+}
+
+exports.ExpressionErrors = ExpressionErrors;

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

@@ -0,0 +1,108 @@
+"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"];
+const RECORD_AND_TUPLE_SYNTAX_TYPES = ["hash", "bar"];
+
+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(", "));
+  }
+
+  if (hasPlugin(plugins, "moduleAttributes")) {
+    if (hasPlugin(plugins, "importAssertions")) {
+      throw new Error("Cannot combine importAssertions and moduleAttributes plugins.");
+    }
+
+    const moduleAttributesVerionPluginOption = getPluginOption(plugins, "moduleAttributes", "version");
+
+    if (moduleAttributesVerionPluginOption !== "may-2020") {
+      throw new Error("The 'moduleAttributes' plugin requires a 'version' option," + " representing the last proposal update. Currently, the" + " only supported value is 'may-2020'.");
+    }
+  }
+
+  if (hasPlugin(plugins, "recordAndTuple") && !RECORD_AND_TUPLE_SYNTAX_TYPES.includes(getPluginOption(plugins, "recordAndTuple", "syntaxType"))) {
+    throw new Error("'recordAndTuple' requires 'syntaxType' option whose value should be one of: " + RECORD_AND_TUPLE_SYNTAX_TYPES.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,297 @@
+"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");
+
+var _error = require("../parser/error");
+
+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;
+  }
+
+  estreeParseDecimalLiteral(value) {
+    const decimal = null;
+    const node = this.estreeParseLiteral(decimal);
+    node.decimal = 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);
+    }
+  }
+
+  getObjectOrClassMethodParams(method) {
+    return method.value.params;
+  }
+
+  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);
+    }
+  }
+
+  checkProto(prop, isRecord, protoRef, refExpressionErrors) {
+    if (prop.method) {
+      return;
+    }
+
+    super.checkProto(prop, isRecord, protoRef, refExpressionErrors);
+  }
+
+  isValidDirective(stmt) {
+    return stmt.type === "ExpressionStatement" && stmt.expression.type === "Literal" && typeof stmt.expression.value === "string" && !stmt.expression.extra?.parenthesized;
+  }
+
+  stmtToDirective(stmt) {
+    const directive = super.stmtToDirective(stmt);
+    const value = stmt.expression.value;
+    directive.value.value = value;
+    return directive;
+  }
+
+  parseBlockBody(node, allowDirectives, topLevel, end) {
+    super.parseBlockBody(node, allowDirectives, topLevel, end);
+    const directiveStatements = node.directives.map(d => this.directiveToStmt(d));
+    node.body = directiveStatements.concat(node.body);
+    delete node.directives;
+  }
+
+  pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) {
+    this.parseMethod(method, isGenerator, isAsync, isConstructor, allowsDirectSuper, "ClassMethod", true);
+
+    if (method.typeParameters) {
+      method.value.typeParameters = method.typeParameters;
+      delete method.typeParameters;
+    }
+
+    classBody.body.push(method);
+  }
+
+  parseExprAtom(refExpressionErrors) {
+    switch (this.state.type) {
+      case _types.types.num:
+      case _types.types.string:
+        return this.estreeParseLiteral(this.state.value);
+
+      case _types.types.regexp:
+        return this.estreeParseRegExpLiteral(this.state.value);
+
+      case _types.types.bigint:
+        return this.estreeParseBigIntLiteral(this.state.value);
+
+      case _types.types.decimal:
+        return this.estreeParseDecimalLiteral(this.state.value);
+
+      case _types.types._null:
+        return this.estreeParseLiteral(null);
+
+      case _types.types._true:
+        return this.estreeParseLiteral(true);
+
+      case _types.types._false:
+        return this.estreeParseLiteral(false);
+
+      default:
+        return super.parseExprAtom(refExpressionErrors);
+    }
+  }
+
+  parseLiteral(value, type, startPos, startLoc) {
+    const node = super.parseLiteral(value, type, startPos, startLoc);
+    node.raw = node.extra.raw;
+    delete node.extra;
+    return node;
+  }
+
+  parseFunctionBody(node, allowExpression, isMethod = false) {
+    super.parseFunctionBody(node, allowExpression, isMethod);
+    node.expression = node.body.type !== "BlockStatement";
+  }
+
+  parseMethod(node, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope = false) {
+    let funcNode = this.startNode();
+    funcNode.kind = node.kind;
+    funcNode = super.parseMethod(funcNode, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope);
+    funcNode.type = "FunctionExpression";
+    delete funcNode.kind;
+    node.value = funcNode;
+    type = type === "ClassMethod" ? "MethodDefinition" : type;
+    return this.finishNode(node, type);
+  }
+
+  parseObjectMethod(prop, isGenerator, isAsync, isPattern, isAccessor) {
+    const node = super.parseObjectMethod(prop, isGenerator, isAsync, isPattern, isAccessor);
+
+    if (node) {
+      node.type = "Property";
+      if (node.kind === "method") node.kind = "init";
+      node.shorthand = false;
+    }
+
+    return node;
+  }
+
+  parseObjectProperty(prop, startPos, startLoc, isPattern, refExpressionErrors) {
+    const node = super.parseObjectProperty(prop, startPos, startLoc, isPattern, refExpressionErrors);
+
+    if (node) {
+      node.kind = "init";
+      node.type = "Property";
+    }
+
+    return node;
+  }
+
+  toAssignable(node) {
+    if (isSimpleProperty(node)) {
+      this.toAssignable(node.value);
+      return node;
+    }
+
+    return super.toAssignable(node);
+  }
+
+  toAssignableObjectExpressionProp(prop, isLast) {
+    if (prop.kind === "get" || prop.kind === "set") {
+      throw this.raise(prop.key.start, _error.Errors.PatternHasAccessor);
+    } else if (prop.method) {
+      throw this.raise(prop.key.start, _error.Errors.PatternHasMethod);
+    } else {
+      super.toAssignableObjectExpressionProp(prop, isLast);
+    }
+  }
+
+  finishCallExpression(node, optional) {
+    super.finishCallExpression(node, optional);
+
+    if (node.callee.type === "Import") {
+      node.type = "ImportExpression";
+      node.source = node.arguments[0];
+      delete node.arguments;
+      delete node.callee;
+    }
+
+    return node;
+  }
+
+  toReferencedArguments(node) {
+    if (node.type === "ImportExpression") {
+      return;
+    }
+
+    super.toReferencedArguments(node);
+  }
+
+  parseExport(node) {
+    super.parseExport(node);
+
+    switch (node.type) {
+      case "ExportAllDeclaration":
+        node.exported = null;
+        break;
+
+      case "ExportNamedDeclaration":
+        if (node.specifiers.length === 1 && node.specifiers[0].type === "ExportNamespaceSpecifier") {
+          node.type = "ExportAllDeclaration";
+          node.exported = node.specifiers[0].exported;
+          delete node.specifiers;
+        }
+
+        break;
+    }
+
+    return node;
+  }
+
+  parseSubscript(base, startPos, startLoc, noCalls, state) {
+    const node = super.parseSubscript(base, startPos, startLoc, noCalls, state);
+
+    if (state.optionalChainMember) {
+      if (node.type === "OptionalMemberExpression" || node.type === "OptionalCallExpression") {
+        node.type = node.type.substring(8);
+      }
+
+      if (state.stop) {
+        const chain = this.startNodeAtNode(node);
+        chain.expression = node;
+        return this.finishNode(chain, "ChainExpression");
+      }
+    } else if (node.type === "MemberExpression" || node.type === "CallExpression") {
+      node.optional = false;
+    }
+
+    return node;
+  }
+
+};
+
+exports.default = _default;

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

@@ -0,0 +1,526 @@
+"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");
+
+var _error = require("../../parser/error");
+
+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+$/;
+const JsxErrors = Object.freeze({
+  AttributeIsEmpty: "JSX attributes must only be assigned a non-empty expression",
+  MissingClosingTagFragment: "Expected corresponding JSX closing tag for <>",
+  MissingClosingTagElement: "Expected corresponding JSX closing tag for <%0>",
+  UnsupportedJsxValue: "JSX value should be either an expression or a quoted JSX text",
+  UnterminatedJsxContent: "Unterminated JSX contents",
+  UnwrappedAdjacentJSXElements: "Adjacent JSX elements must be wrapped in an enclosing tag. Did you want a JSX fragment <>...</>?"
+});
+_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, JsxErrors.UnterminatedJsxContent);
+      }
+
+      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, _error.Errors.UnterminatedString);
+      }
+
+      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, JsxErrors.AttributeIsEmpty);
+        }
+
+        return node;
+
+      case _types.types.jsxTagStart:
+      case _types.types.string:
+        return this.parseExprAtom();
+
+      default:
+        throw this.raise(this.state.start, JsxErrors.UnsupportedJsxValue);
+    }
+  }
+
+  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.parseMaybeAssignAllowIn();
+      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, JsxErrors.MissingClosingTagFragment);
+      } else if (!isFragment(openingElement) && isFragment(closingElement)) {
+        this.raise(closingElement.start, JsxErrors.MissingClosingTagElement, getQualifiedJSXName(openingElement.name));
+      } else if (!isFragment(openingElement) && !isFragment(closingElement)) {
+        if (getQualifiedJSXName(closingElement.name) !== getQualifiedJSXName(openingElement.name)) {
+          this.raise(closingElement.start, JsxErrors.MissingClosingTagElement, 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, JsxErrors.UnwrappedAdjacentJSXElements);
+    }
+
+    return isFragment(openingElement) ? this.finishNode(node, "JSXFragment") : this.finishNode(node, "JSXElement");
+  }
+
+  jsxParseElement() {
+    const startPos = this.state.start;
+    const startLoc = this.state.startLoc;
+    this.next();
+    return this.jsxParseElementAt(startPos, startLoc);
+  }
+
+  parseExprAtom(refExpressionErrors) {
+    if (this.match(_types.types.jsxText)) {
+      return this.parseLiteral(this.state.value, "JSXText");
+    } else if (this.match(_types.types.jsxTagStart)) {
+      return this.jsxParseElement();
+    } else if (this.isRelational("<") && this.input.charCodeAt(this.state.pos) !== 33) {
+      this.finishToken(_types.types.jsxTagStart);
+      return this.jsxParseElement();
+    } else {
+      return super.parseExprAtom(refExpressionErrors);
+    }
+  }
+
+  getTokenFromCode(code) {
+    if (this.state.inPropertyName) return super.getTokenFromCode(code);
+    const context = this.curContext();
+
+    if (context === _context.types.j_expr) {
+      return this.jsxReadToken();
+    }
+
+    if (context === _context.types.j_oTag || context === _context.types.j_cTag) {
+      if ((0, _identifier.isIdentifierStart)(code)) {
+        return this.jsxReadWord();
+      }
+
+      if (code === 62) {
+        ++this.state.pos;
+        return this.finishToken(_types.types.jsxTagEnd);
+      }
+
+      if ((code === 34 || code === 39) && context === _context.types.j_oTag) {
+        return this.jsxReadString(code);
+      }
+    }
+
+    if (code === 60 && this.state.exprAllowed && this.input.charCodeAt(this.state.pos + 1) !== 33) {
+      ++this.state.pos;
+      return this.finishToken(_types.types.jsxTagStart);
+    }
+
+    return super.getTokenFromCode(code);
+  }
+
+  updateContext(prevType) {
+    if (this.match(_types.types.braceL)) {
+      const curContext = this.curContext();
+
+      if (curContext === _context.types.j_oTag) {
+        this.state.context.push(_context.types.braceExpression);
+      } else if (curContext === _context.types.j_expr) {
+        this.state.context.push(_context.types.templateQuasi);
+      } else {
+        super.updateContext(prevType);
+      }
+
+      this.state.exprAllowed = true;
+    } else if (this.match(_types.types.slash) && prevType === _types.types.jsxTagStart) {
+      this.state.context.length -= 2;
+      this.state.context.push(_context.types.j_cTag);
+      this.state.exprAllowed = false;
+    } else {
+      return super.updateContext(prevType);
+    }
+  }
+
+};
+
+exports.default = _default;

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

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

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

@@ -0,0 +1,219 @@
+"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 oldStrict = this.state.strict;
+    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, oldStrict);
+    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);
+  }
+
+  isExportDefaultSpecifier() {
+    if (this.match(_types.types._default)) {
+      const next = this.nextTokenStart();
+
+      if (this.isUnparsedContextual(next, "from")) {
+        if (this.input.startsWith(_types.types.placeholder.label, this.nextTokenStartSince(next + 4))) {
+          return true;
+        }
+      }
+    }
+
+    return super.isExportDefaultSpecifier();
+  }
+
+  maybeParseExportDefaultSpecifier(node) {
+    if (node.specifiers && node.specifiers.length > 0) {
+      return true;
+    }
+
+    return super.maybeParseExportDefaultSpecifier(...arguments);
+  }
+
+  checkExport(node) {
+    const {
+      specifiers
+    } = node;
+
+    if (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,110 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.types = exports.TokContext = void 0;
+
+var _types = require("./types");
+
+class TokContext {
+  constructor(token, isExpr, preserveSpace, override) {
+    this.token = void 0;
+    this.isExpr = void 0;
+    this.preserveSpace = void 0;
+    this.override = void 0;
+    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),
+  recordExpression: 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 && prevType !== _types.types._function && prevType !== _types.types._class) {
+      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 && this.hasPrecedingLineBreak()) && !((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;
+};
+
+_types.types.braceHashL.updateContext = function () {
+  this.state.context.push(types.recordExpression);
+  this.state.exprAllowed = true;
+};

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

@@ -0,0 +1,99 @@
+"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.strict = void 0;
+    this.curLine = void 0;
+    this.startLoc = void 0;
+    this.endLoc = void 0;
+    this.errors = [];
+    this.potentialArrowAt = -1;
+    this.noArrowAt = [];
+    this.noArrowParamsConversionAt = [];
+    this.maybeInArrowParameters = false;
+    this.inPipeline = false;
+    this.inType = false;
+    this.noAnonFunctionType = false;
+    this.inPropertyName = false;
+    this.hasFlowComment = false;
+    this.isIterator = false;
+    this.isDeclareContext = false;
+    this.topicContext = {
+      maxNumOfResolvableTopics: 0,
+      maxTopicIndex: null
+    };
+    this.soloAwait = false;
+    this.inFSharpPipelineDirectBody = false;
+    this.labels = [];
+    this.decoratorStack = [[]];
+    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.octalPositions = [];
+    this.exportedIdentifiers = [];
+    this.tokensLength = 0;
+  }
+
+  init(options) {
+    this.strict = options.strictMode === false ? false : options.sourceType === "module";
+    this.curLine = options.startLine;
+    this.startLoc = this.endLoc = this.curPosition();
+  }
+
+  curPosition() {
+    return new _location.Position(this.curLine, this.pos - this.lineStart);
+  }
+
+  clone(skipArrays) {
+    const state = new State();
+    const keys = Object.keys(this);
+
+    for (let i = 0, length = keys.length; i < length; i++) {
+      const key = keys[i];
+      let val = this[key];
+
+      if (!skipArrays && Array.isArray(val)) {
+        val = val.slice();
+      }
+
+      state[key] = val;
+    }
+
+    return state;
+  }
+
+}
+
+exports.default = State;

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

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

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

@@ -0,0 +1,99 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.ClassScope = void 0;
+
+var _scopeflags = require("./scopeflags");
+
+var _error = require("../parser/error");
+
+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.raise(pos, _error.Errors.InvalidPrivateFieldResolution, name);
+      }
+    }
+  }
+
+  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, _error.Errors.PrivateNameRedeclaration, 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.raise(pos, _error.Errors.InvalidPrivateFieldResolution, name);
+    }
+  }
+
+}
+
+exports.default = ClassScopeHandler;

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

@@ -0,0 +1,138 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.newParameterDeclarationScope = newParameterDeclarationScope;
+exports.newArrowHeadScope = newArrowHeadScope;
+exports.newAsyncArrowScope = newAsyncArrowScope;
+exports.newExpressionScope = newExpressionScope;
+exports.default = void 0;
+const kExpression = 0,
+      kMaybeArrowParameterDeclaration = 1,
+      kMaybeAsyncArrowParameterDeclaration = 2,
+      kParameterDeclaration = 3;
+
+class ExpressionScope {
+  constructor(type = kExpression) {
+    this.type = void 0;
+    this.type = type;
+  }
+
+  canBeArrowParameterDeclaration() {
+    return this.type === kMaybeAsyncArrowParameterDeclaration || this.type === kMaybeArrowParameterDeclaration;
+  }
+
+  isCertainlyParameterDeclaration() {
+    return this.type === kParameterDeclaration;
+  }
+
+}
+
+class ArrowHeadParsingScope extends ExpressionScope {
+  constructor(type) {
+    super(type);
+    this.errors = new Map();
+  }
+
+  recordDeclarationError(pos, message) {
+    this.errors.set(pos, message);
+  }
+
+  clearDeclarationError(pos) {
+    this.errors.delete(pos);
+  }
+
+  iterateErrors(iterator) {
+    this.errors.forEach(iterator);
+  }
+
+}
+
+class ExpressionScopeHandler {
+  constructor(raise) {
+    this.stack = [new ExpressionScope()];
+    this.raise = raise;
+  }
+
+  enter(scope) {
+    this.stack.push(scope);
+  }
+
+  exit() {
+    this.stack.pop();
+  }
+
+  recordParameterInitializerError(pos, message) {
+    const {
+      stack
+    } = this;
+    let i = stack.length - 1;
+    let scope = stack[i];
+
+    while (!scope.isCertainlyParameterDeclaration()) {
+      if (scope.canBeArrowParameterDeclaration()) {
+        scope.recordDeclarationError(pos, message);
+      } else {
+        return;
+      }
+
+      scope = stack[--i];
+    }
+
+    this.raise(pos, message);
+  }
+
+  recordAsyncArrowParametersError(pos, message) {
+    const {
+      stack
+    } = this;
+    let i = stack.length - 1;
+    let scope = stack[i];
+
+    while (scope.canBeArrowParameterDeclaration()) {
+      if (scope.type === kMaybeAsyncArrowParameterDeclaration) {
+        scope.recordDeclarationError(pos, message);
+      }
+
+      scope = stack[--i];
+    }
+  }
+
+  validateAsPattern() {
+    const {
+      stack
+    } = this;
+    const currentScope = stack[stack.length - 1];
+    if (!currentScope.canBeArrowParameterDeclaration()) return;
+    currentScope.iterateErrors((message, pos) => {
+      this.raise(pos, message);
+      let i = stack.length - 2;
+      let scope = stack[i];
+
+      while (scope.canBeArrowParameterDeclaration()) {
+        scope.clearDeclarationError(pos);
+        scope = stack[--i];
+      }
+    });
+  }
+
+}
+
+exports.default = ExpressionScopeHandler;
+
+function newParameterDeclarationScope() {
+  return new ExpressionScope(kParameterDeclaration);
+}
+
+function newArrowHeadScope() {
+  return new ArrowHeadParsingScope(kMaybeArrowParameterDeclaration);
+}
+
+function newAsyncArrowScope() {
+  return new ArrowHeadParsingScope(kMaybeAsyncArrowParameterDeclaration);
+}
+
+function newExpressionScope() {
+  return new ExpressionScope();
+}

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

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isIteratorStart = isIteratorStart;
+Object.defineProperty(exports, "isIdentifierStart", {
+  enumerable: true,
+  get: function () {
+    return _helperValidatorIdentifier.isIdentifierStart;
+  }
+});
+Object.defineProperty(exports, "isIdentifierChar", {
+  enumerable: true,
+  get: function () {
+    return _helperValidatorIdentifier.isIdentifierChar;
+  }
+});
+Object.defineProperty(exports, "isReservedWord", {
+  enumerable: true,
+  get: function () {
+    return _helperValidatorIdentifier.isReservedWord;
+  }
+});
+Object.defineProperty(exports, "isStrictBindOnlyReservedWord", {
+  enumerable: true,
+  get: function () {
+    return _helperValidatorIdentifier.isStrictBindOnlyReservedWord;
+  }
+});
+Object.defineProperty(exports, "isStrictBindReservedWord", {
+  enumerable: true,
+  get: function () {
+    return _helperValidatorIdentifier.isStrictBindReservedWord;
+  }
+});
+Object.defineProperty(exports, "isStrictReservedWord", {
+  enumerable: true,
+  get: function () {
+    return _helperValidatorIdentifier.isStrictReservedWord;
+  }
+});
+Object.defineProperty(exports, "isKeyword", {
+  enumerable: true,
+  get: function () {
+    return _helperValidatorIdentifier.isKeyword;
+  }
+});
+exports.keywordRelationalOperator = void 0;
+
+var _helperValidatorIdentifier = require("@babel/helper-validator-identifier");
+
+const keywordRelationalOperator = /^in(stanceof)?$/;
+exports.keywordRelationalOperator = keywordRelationalOperator;
+
+function isIteratorStart(current, next) {
+  return current === 64 && next === 64;
+}

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

@@ -0,0 +1,49 @@
+"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 = void 0;
+    this.column = void 0;
+    this.line = line;
+    this.column = col;
+  }
+
+}
+
+exports.Position = Position;
+
+class SourceLocation {
+  constructor(start, end) {
+    this.start = void 0;
+    this.end = void 0;
+    this.filename = void 0;
+    this.identifierName = void 0;
+    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/production-parameter.js

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

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

@@ -0,0 +1,168 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.Scope = void 0;
+
+var _scopeflags = require("./scopeflags");
+
+var N = _interopRequireWildcard(require("../types"));
+
+var _error = require("../parser/error");
+
+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.flags = void 0;
+    this.var = [];
+    this.lexical = [];
+    this.functions = [];
+    this.flags = flags;
+  }
+
+}
+
+exports.Scope = Scope;
+
+class ScopeHandler {
+  constructor(raise, inModule) {
+    this.scopeStack = [];
+    this.undefinedExports = new Map();
+    this.undefinedPrivateNames = new Map();
+    this.raise = raise;
+    this.inModule = inModule;
+  }
+
+  get inFunction() {
+    return (this.currentVarScope().flags & _scopeflags.SCOPE_FUNCTION) > 0;
+  }
+
+  get allowSuper() {
+    return (this.currentThisScope().flags & _scopeflags.SCOPE_SUPER) > 0;
+  }
+
+  get allowDirectSuper() {
+    return (this.currentThisScope().flags & _scopeflags.SCOPE_DIRECT_SUPER) > 0;
+  }
+
+  get inClass() {
+    return (this.currentThisScope().flags & _scopeflags.SCOPE_CLASS) > 0;
+  }
+
+  get inNonArrowFunction() {
+    return (this.currentThisScope().flags & _scopeflags.SCOPE_FUNCTION) > 0;
+  }
+
+  get treatFunctionsAsVar() {
+    return this.treatFunctionsAsVarInScope(this.currentScope());
+  }
+
+  createScope(flags) {
+    return new Scope(flags);
+  }
+
+  enter(flags) {
+    this.scopeStack.push(this.createScope(flags));
+  }
+
+  exit() {
+    this.scopeStack.pop();
+  }
+
+  treatFunctionsAsVarInScope(scope) {
+    return !!(scope.flags & _scopeflags.SCOPE_FUNCTION || !this.inModule && scope.flags & _scopeflags.SCOPE_PROGRAM);
+  }
+
+  declareName(name, bindingType, pos) {
+    let scope = this.currentScope();
+
+    if (bindingType & _scopeflags.BIND_SCOPE_LEXICAL || bindingType & _scopeflags.BIND_SCOPE_FUNCTION) {
+      this.checkRedeclarationInScope(scope, name, bindingType, pos);
+
+      if (bindingType & _scopeflags.BIND_SCOPE_FUNCTION) {
+        scope.functions.push(name);
+      } else {
+        scope.lexical.push(name);
+      }
+
+      if (bindingType & _scopeflags.BIND_SCOPE_LEXICAL) {
+        this.maybeExportDefined(scope, name);
+      }
+    } else if (bindingType & _scopeflags.BIND_SCOPE_VAR) {
+      for (let i = this.scopeStack.length - 1; i >= 0; --i) {
+        scope = this.scopeStack[i];
+        this.checkRedeclarationInScope(scope, name, bindingType, pos);
+        scope.var.push(name);
+        this.maybeExportDefined(scope, name);
+        if (scope.flags & _scopeflags.SCOPE_VAR) break;
+      }
+    }
+
+    if (this.inModule && scope.flags & _scopeflags.SCOPE_PROGRAM) {
+      this.undefinedExports.delete(name);
+    }
+  }
+
+  maybeExportDefined(scope, name) {
+    if (this.inModule && scope.flags & _scopeflags.SCOPE_PROGRAM) {
+      this.undefinedExports.delete(name);
+    }
+  }
+
+  checkRedeclarationInScope(scope, name, bindingType, pos) {
+    if (this.isRedeclaredInScope(scope, name, bindingType)) {
+      this.raise(pos, _error.Errors.VarRedeclaration, name);
+    }
+  }
+
+  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,90 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CLASS_ELEMENT_OTHER = exports.CLASS_ELEMENT_INSTANCE_SETTER = exports.CLASS_ELEMENT_INSTANCE_GETTER = exports.CLASS_ELEMENT_STATIC_SETTER = exports.CLASS_ELEMENT_STATIC_GETTER = exports.CLASS_ELEMENT_KIND_ACCESSOR = exports.CLASS_ELEMENT_KIND_SETTER = exports.CLASS_ELEMENT_KIND_GETTER = exports.CLASS_ELEMENT_FLAG_STATIC = exports.BIND_TS_NAMESPACE = exports.BIND_TS_CONST_ENUM = exports.BIND_OUTSIDE = exports.BIND_NONE = exports.BIND_TS_AMBIENT = exports.BIND_TS_ENUM = exports.BIND_TS_TYPE = exports.BIND_TS_INTERFACE = exports.BIND_FUNCTION = exports.BIND_VAR = exports.BIND_LEXICAL = exports.BIND_CLASS = exports.BIND_FLAGS_TS_EXPORT_ONLY = exports.BIND_FLAGS_TS_CONST_ENUM = exports.BIND_FLAGS_TS_ENUM = exports.BIND_FLAGS_CLASS = exports.BIND_FLAGS_NONE = exports.BIND_SCOPE_OUTSIDE = exports.BIND_SCOPE_FUNCTION = exports.BIND_SCOPE_LEXICAL = exports.BIND_SCOPE_VAR = exports.BIND_KIND_TYPE = exports.BIND_KIND_VALUE = exports.SCOPE_VAR = exports.SCOPE_TS_MODULE = exports.SCOPE_CLASS = exports.SCOPE_DIRECT_SUPER = exports.SCOPE_SUPER = exports.SCOPE_SIMPLE_CATCH = exports.SCOPE_ARROW = exports.SCOPE_FUNCTION = exports.SCOPE_PROGRAM = exports.SCOPE_OTHER = void 0;
+const SCOPE_OTHER = 0b00000000,
+      SCOPE_PROGRAM = 0b00000001,
+      SCOPE_FUNCTION = 0b00000010,
+      SCOPE_ARROW = 0b00000100,
+      SCOPE_SIMPLE_CATCH = 0b00001000,
+      SCOPE_SUPER = 0b00010000,
+      SCOPE_DIRECT_SUPER = 0b00100000,
+      SCOPE_CLASS = 0b01000000,
+      SCOPE_TS_MODULE = 0b10000000,
+      SCOPE_VAR = SCOPE_PROGRAM | SCOPE_FUNCTION | SCOPE_TS_MODULE;
+exports.SCOPE_VAR = SCOPE_VAR;
+exports.SCOPE_TS_MODULE = SCOPE_TS_MODULE;
+exports.SCOPE_CLASS = SCOPE_CLASS;
+exports.SCOPE_DIRECT_SUPER = SCOPE_DIRECT_SUPER;
+exports.SCOPE_SUPER = SCOPE_SUPER;
+exports.SCOPE_SIMPLE_CATCH = SCOPE_SIMPLE_CATCH;
+exports.SCOPE_ARROW = SCOPE_ARROW;
+exports.SCOPE_FUNCTION = SCOPE_FUNCTION;
+exports.SCOPE_PROGRAM = SCOPE_PROGRAM;
+exports.SCOPE_OTHER = SCOPE_OTHER;
+const BIND_KIND_VALUE = 0b00000_0000_01,
+      BIND_KIND_TYPE = 0b00000_0000_10,
+      BIND_SCOPE_VAR = 0b00000_0001_00,
+      BIND_SCOPE_LEXICAL = 0b00000_0010_00,
+      BIND_SCOPE_FUNCTION = 0b00000_0100_00,
+      BIND_SCOPE_OUTSIDE = 0b00000_1000_00,
+      BIND_FLAGS_NONE = 0b00001_0000_00,
+      BIND_FLAGS_CLASS = 0b00010_0000_00,
+      BIND_FLAGS_TS_ENUM = 0b00100_0000_00,
+      BIND_FLAGS_TS_CONST_ENUM = 0b01000_0000_00,
+      BIND_FLAGS_TS_EXPORT_ONLY = 0b10000_0000_00;
+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 = 0b1_00,
+      CLASS_ELEMENT_KIND_GETTER = 0b0_10,
+      CLASS_ELEMENT_KIND_SETTER = 0b0_01,
+      CLASS_ELEMENT_KIND_ACCESSOR = CLASS_ELEMENT_KIND_GETTER | CLASS_ELEMENT_KIND_SETTER;
+exports.CLASS_ELEMENT_KIND_ACCESSOR = CLASS_ELEMENT_KIND_ACCESSOR;
+exports.CLASS_ELEMENT_KIND_SETTER = CLASS_ELEMENT_KIND_SETTER;
+exports.CLASS_ELEMENT_KIND_GETTER = CLASS_ELEMENT_KIND_GETTER;
+exports.CLASS_ELEMENT_FLAG_STATIC = CLASS_ELEMENT_FLAG_STATIC;
+const CLASS_ELEMENT_STATIC_GETTER = CLASS_ELEMENT_KIND_GETTER | CLASS_ELEMENT_FLAG_STATIC,
+      CLASS_ELEMENT_STATIC_SETTER = CLASS_ELEMENT_KIND_SETTER | CLASS_ELEMENT_FLAG_STATIC,
+      CLASS_ELEMENT_INSTANCE_GETTER = CLASS_ELEMENT_KIND_GETTER,
+      CLASS_ELEMENT_INSTANCE_SETTER = CLASS_ELEMENT_KIND_SETTER,
+      CLASS_ELEMENT_OTHER = 0;
+exports.CLASS_ELEMENT_OTHER = CLASS_ELEMENT_OTHER;
+exports.CLASS_ELEMENT_INSTANCE_SETTER = CLASS_ELEMENT_INSTANCE_SETTER;
+exports.CLASS_ELEMENT_INSTANCE_GETTER = CLASS_ELEMENT_INSTANCE_GETTER;
+exports.CLASS_ELEMENT_STATIC_SETTER = CLASS_ELEMENT_STATIC_SETTER;
+exports.CLASS_ELEMENT_STATIC_GETTER = CLASS_ELEMENT_STATIC_GETTER;

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

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

node_modules/@babel/parser/package.json

@@ -0,0 +1,81 @@
+{
+  "_args": [
+    [
+      "@babel/parser@7.12.5",
+      "J:\\Github\\CURD-TS"
+    ]
+  ],
+  "_development": true,
+  "_from": "@babel/parser@7.12.5",
+  "_id": "@babel/parser@7.12.5",
+  "_inBundle": false,
+  "_integrity": "sha1-tK8y3dRzwL+mQ71/8HKLjnG4HqA=",
+  "_location": "/@babel/parser",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "@babel/parser@7.12.5",
+    "name": "@babel/parser",
+    "escapedName": "@babel%2fparser",
+    "scope": "@babel",
+    "rawSpec": "7.12.5",
+    "saveSpec": null,
+    "fetchSpec": "7.12.5"
+  },
+  "_requiredBy": [
+    "/@vue/compiler-core",
+    "/@vue/compiler-sfc",
+    "/vite"
+  ],
+  "_resolved": "http://192.168.250.101:4873/@babel%2fparser/-/parser-7.12.5.tgz",
+  "_spec": "7.12.5",
+  "_where": "J:\\Github\\CURD-TS",
+  "author": {
+    "name": "Sebastian McKenzie",
+    "email": "sebmck@gmail.com"
+  },
+  "bin": {
+    "parser": "./bin/babel-parser.js"
+  },
+  "bugs": {
+    "url": "https://github.com/babel/babel/issues"
+  },
+  "description": "A JavaScript parser",
+  "devDependencies": {
+    "@babel/code-frame": "7.10.4",
+    "@babel/helper-fixtures": "7.10.5",
+    "@babel/helper-validator-identifier": "7.10.4",
+    "charcodes": "^0.2.0"
+  },
+  "engines": {
+    "node": ">=6.0.0"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "typings"
+  ],
+  "homepage": "https://babeljs.io/",
+  "keywords": [
+    "babel",
+    "javascript",
+    "parser",
+    "tc39",
+    "ecmascript",
+    "@babel/parser"
+  ],
+  "license": "MIT",
+  "main": "lib/index.js",
+  "name": "@babel/parser",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/babel/babel.git",
+    "directory": "packages/babel-parser"
+  },
+  "types": "typings/babel-parser.d.ts",
+  "version": "7.12.5"
+}

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

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