(item: T): T {
+ return item;
+ }
+}
+```
+
+Allow typeAnnotations for yield expressions ([#174](https://github.com/babel/babylon/pull/174))) (Daniel Tschinder)
+
+```js
+function *foo() {
+ const x = (yield 5: any);
+}
+```
+
+### :nail_care: Polish
+
+Annotate more errors with expected token ([#172](https://github.com/babel/babylon/pull/172))) (Moti Zilberman)
+
+```js
+// Unexpected token, expected ; (1:6)
+{ set 1 }
+```
+
+### :house: Internal
+
+Remove kcheck ([#173](https://github.com/babel/babylon/pull/173))) (Daniel Tschinder)
+
+Also run flow, linting, babel tests on separate instances (add back node 0.10)
+
+## v6.11.6 (2016-10-12)
+
+### :bug: Bug Fix/Regression
+
+Fix crash when exporting with destructuring and sparse array ([#170](https://github.com/babel/babylon/pull/170)) (Jeroen Engels)
+
+```js
+// was failing with `Cannot read property 'type' of null` because of null identifiers
+export const { foo: [ ,, qux7 ] } = bar;
+```
+
+## v6.11.5 (2016-10-12)
+
+### :eyeglasses: Spec Compliance
+
+Fix: Check for duplicate named exports in exported destructuring assignments ([#144](https://github.com/babel/babylon/pull/144)) (Kai Cataldo)
+
+```js
+// `foo` has already been exported. Exported identifiers must be unique. (2:20)
+export function foo() {};
+export const { a: [{foo}] } = bar;
+```
+
+Fix: Check for duplicate named exports in exported rest elements/properties ([#164](https://github.com/babel/babylon/pull/164)) (Kai Cataldo)
+
+```js
+// `foo` has already been exported. Exported identifiers must be unique. (2:22)
+export const foo = 1;
+export const [bar, ...foo] = baz;
+```
+
+### :bug: Bug Fix
+
+Fix: Allow identifier `async` for default param in arrow expression ([#165](https://github.com/babel/babylon/pull/165)) (Kai Cataldo)
+
+```js
+// this is ok now
+const test = ({async = true}) => {};
+```
+
+### :nail_care: Polish
+
+Babylon will now print out the token it's expecting if there's a `SyntaxError` ([#150](https://github.com/babel/babylon/pull/150)) (Daniel Tschinder)
+
+```bash
+# So in the case of a missing ending curly (`}`)
+Module build failed: SyntaxError: Unexpected token, expected } (30:0)
+ 28 | }
+ 29 |
+> 30 |
+ | ^
+```
+
+## v6.11.4 (2016-10-03)
+
+Temporary rollback for erroring on trailing comma with spread (#154) (Henry Zhu)
+
+## v6.11.3 (2016-10-01)
+
+### :eyeglasses: Spec Compliance
+
+Add static errors for object rest (#149) ([@danez](https://github.com/danez))
+
+> https://github.com/sebmarkbage/ecmascript-rest-spread
+
+Object rest copies the *rest* of properties from the right hand side `obj` starting from the left to right.
+
+```js
+let { x, y, ...z } = { x: 1, y: 2, z: 3 };
+// x = 1
+// y = 2
+// z = { z: 3 }
+```
+
+#### New Syntax Errors:
+
+**SyntaxError**: The rest element has to be the last element when destructuring (1:10)
+```bash
+> 1 | let { ...x, y, z } = { x: 1, y: 2, z: 3};
+ | ^
+# Previous behavior:
+# x = { x: 1, y: 2, z: 3 }
+# y = 2
+# z = 3
+```
+
+Before, this was just a more verbose way of shallow copying `obj` since it doesn't actually do what you think.
+
+**SyntaxError**: Cannot have multiple rest elements when destructuring (1:13)
+
+```bash
+> 1 | let { x, ...y, ...z } = { x: 1, y: 2, z: 3};
+ | ^
+# Previous behavior:
+# x = 1
+# y = { y: 2, z: 3 }
+# z = { y: 2, z: 3 }
+```
+
+Before y and z would just be the same value anyway so there is no reason to need to have both.
+
+**SyntaxError**: A trailing comma is not permitted after the rest element (1:16)
+
+```js
+let { x, y, ...z, } = obj;
+```
+
+The rationale for this is that the use case for trailing comma is that you can add something at the end without affecting the line above. Since a RestProperty always has to be the last property it doesn't make sense.
+
+---
+
+get / set are valid property names in default assignment (#142) ([@jezell](https://github.com/jezell))
+
+```js
+// valid
+function something({ set = null, get = null }) {}
+```
+
+## v6.11.2 (2016-09-23)
+
+### Bug Fix
+
+- [#139](https://github.com/babel/babylon/issues/139) Don't do the duplicate check if not an identifier (#140) @hzoo
+
+```js
+// regression with duplicate export check
+SyntaxError: ./typography.js: `undefined` has already been exported. Exported identifiers must be unique. (22:13)
+ 20 |
+ 21 | export const { rhythm } = typography;
+> 22 | export const { TypographyStyle } = typography
+```
+
+Bail out for now, and make a change to account for destructuring in the next release.
+
+## 6.11.1 (2016-09-22)
+
+### Bug Fix
+- [#137](https://github.com/babel/babylon/pull/137) - Fix a regression with duplicate exports - it was erroring on all keys in `Object.prototype`. @danez
+
+```javascript
+export toString from './toString';
+```
+
+```bash
+`toString` has already been exported. Exported identifiers must be unique. (1:7)
+> 1 | export toString from './toString';
+ | ^
+ 2 |
+```
+
+## 6.11.0 (2016-09-22)
+
+### Spec Compliance (will break CI)
+
+- Disallow duplicate named exports ([#107](https://github.com/babel/babylon/pull/107)) @kaicataldo
+
+```js
+// Only one default export allowed per module. (2:9)
+export default function() {};
+export { foo as default };
+
+// Only one default export allowed per module. (2:0)
+export default {};
+export default function() {};
+
+// `Foo` has already been exported. Exported identifiers must be unique. (2:0)
+export { Foo };
+export class Foo {};
+```
+
+### New Feature (Syntax)
+
+- Add support for computed class property names ([#121](https://github.com/babel/babylon/pull/121)) @motiz88
+
+```js
+// AST
+interface ClassProperty <: Node {
+ type: "ClassProperty";
+ key: Identifier;
+ value: Expression;
+ computed: boolean; // added
+}
+```
+
+```js
+// with "plugins": ["classProperties"]
+class Foo {
+ [x]
+ ['y']
+}
+
+class Bar {
+ [p]
+ [m] () {}
+}
+ ```
+
+### Bug Fix
+
+- Fix `static` property falling through in the declare class Flow AST ([#135](https://github.com/babel/babylon/pull/135)) @danharper
+
+```js
+declare class X {
+ a: number;
+ static b: number; // static
+ c: number; // this was being marked as static in the AST as well
+}
+```
+
+### Polish
+
+- Rephrase "assigning/binding to rvalue" errors to include context ([#119](https://github.com/babel/babylon/pull/119)) @motiz88
+
+```js
+// Used to error with:
+// SyntaxError: Assigning to rvalue (1:0)
+
+// Now:
+// Invalid left-hand side in assignment expression (1:0)
+3 = 4
+
+// Invalid left-hand side in for-in statement (1:5)
+for (+i in {});
+```
+
+### Internal
+
+- Fix call to `this.parseMaybeAssign` with correct arguments ([#133](https://github.com/babel/babylon/pull/133)) @danez
+- Add semver note to changelog ([#131](https://github.com/babel/babylon/pull/131)) @hzoo
+
+## 6.10.0 (2016-09-19)
+
+> We plan to include some spec compliance bugs in patch versions. An example was the multiple default exports issue.
+
+### Spec Compliance
+
+* Implement ES2016 check for simple parameter list in strict mode ([#106](https://github.com/babel/babylon/pull/106)) (Timothy Gu)
+
+> It is a Syntax Error if ContainsUseStrict of FunctionBody is true and IsSimpleParameterList of FormalParameters is false. https://tc39.github.io/ecma262/2016/#sec-function-definitions-static-semantics-early-errors
+
+More Context: [tc39-notes](https://github.com/rwaldron/tc39-notes/blob/master/es7/2015-07/july-29.md#611-the-scope-of-use-strict-with-respect-to-destructuring-in-parameter-lists)
+
+For example:
+
+```js
+// this errors because it uses destructuring and default parameters
+// in a function with a "use strict" directive
+function a([ option1, option2 ] = []) {
+ "use strict";
+}
+ ```
+
+The solution would be to use a top level "use strict" or to remove the destructuring or default parameters when using a function + "use strict" or to.
+
+### New Feature
+
+* Exact object type annotations for Flow plugin ([#104](https://github.com/babel/babylon/pull/104)) (Basil Hosmer)
+
+Added to flow in https://github.com/facebook/flow/commit/c710c40aa2a115435098d6c0dfeaadb023cd39b8
+
+Looks like:
+
+```js
+var a : {| x: number, y: string |} = { x: 0, y: 'foo' };
+```
+
+### Bug Fixes
+
+* Include `typeParameter` location in `ArrowFunctionExpression` ([#126](https://github.com/babel/babylon/pull/126)) (Daniel Tschinder)
+* Error on invalid flow type annotation with default assignment ([#122](https://github.com/babel/babylon/pull/122)) (Dan Harper)
+* Fix Flow return types on arrow functions ([#124](https://github.com/babel/babylon/pull/124)) (Dan Harper)
+
+### Misc
+
+* Add tests for export extensions ([#127](https://github.com/babel/babylon/pull/127)) (Daniel Tschinder)
+* Fix Contributing guidelines [skip ci] (Daniel Tschinder)
+
+## 6.9.2 (2016-09-09)
+
+The only change is to remove the `babel-runtime` dependency by compiling with Babel's ES2015 loose mode. So using babylon standalone should be smaller.
+
+## 6.9.1 (2016-08-23)
+
+This release contains mainly small bugfixes but also updates babylons default mode to es2017. The features for `exponentiationOperator`, `asyncFunctions` and `trailingFunctionCommas` which previously needed to be activated via plugin are now enabled by default and the plugins are now no-ops.
+
+### Bug Fixes
+
+- Fix issues with default object params in async functions ([#96](https://github.com/babel/babylon/pull/96)) @danez
+- Fix issues with flow-types and async function ([#95](https://github.com/babel/babylon/pull/95)) @danez
+- Fix arrow functions with destructuring, types & default value ([#94](https://github.com/babel/babylon/pull/94)) @danharper
+- Fix declare class with qualified type identifier ([#97](https://github.com/babel/babylon/pull/97)) @danez
+- Remove exponentiationOperator, asyncFunctions, trailingFunctionCommas plugins and enable them by default ([#98](https://github.com/babel/babylon/pull/98)) @danez
+
+## 6.9.0 (2016-08-16)
+
+### New syntax support
+
+- Add JSX spread children ([#42](https://github.com/babel/babylon/pull/42)) @calebmer
+
+(Be aware that React is not going to support this syntax)
+
+```js
+
+ {...todos.map(todo => )}
+
+```
+
+- Add support for declare module.exports ([#72](https://github.com/babel/babylon/pull/72)) @danez
+
+```js
+declare module "foo" {
+ declare module.exports: {}
+}
+```
+
+### New Features
+
+- If supplied, attach filename property to comment node loc. ([#80](https://github.com/babel/babylon/pull/80)) @divmain
+- Add identifier name to node loc field ([#90](https://github.com/babel/babylon/pull/90)) @kittens
+
+### Bug Fixes
+
+- Fix exponential operator to behave according to spec ([#75](https://github.com/babel/babylon/pull/75)) @danez
+- Fix lookahead to not add comments to arrays which are not cloned ([#76](https://github.com/babel/babylon/pull/76)) @danez
+- Fix accidental fall-through in Flow type parsing. ([#82](https://github.com/babel/babylon/pull/82)) @xiemaisi
+- Only allow declares inside declare module ([#73](https://github.com/babel/babylon/pull/73)) @danez
+- Small fix for parsing type parameter declarations ([#83](https://github.com/babel/babylon/pull/83)) @gabelevi
+- Fix arrow param locations with flow types ([#57](https://github.com/babel/babylon/pull/57)) @danez
+- Fixes SyntaxError position with flow optional type ([#65](https://github.com/babel/babylon/pull/65)) @danez
+
+### Internal
+
+- Add codecoverage to tests @danez
+- Fix tests to not save expected output if we expect the test to fail @danez
+- Make a shallow clone of babel for testing @danez
+- chore(package): update cross-env to version 2.0.0 ([#77](https://github.com/babel/babylon/pull/77)) @greenkeeperio-bot
+- chore(package): update ava to version 0.16.0 ([#86](https://github.com/babel/babylon/pull/86)) @greenkeeperio-bot
+- chore(package): update babel-plugin-istanbul to version 2.0.0 ([#89](https://github.com/babel/babylon/pull/89)) @greenkeeperio-bot
+- chore(package): update nyc to version 8.0.0 ([#88](https://github.com/babel/babylon/pull/88)) @greenkeeperio-bot
+
+## 6.8.4 (2016-07-06)
+
+### Bug Fixes
+
+- Fix the location of params, when flow and default value used ([#68](https://github.com/babel/babylon/pull/68)) @danez
+
+## 6.8.3 (2016-07-02)
+
+### Bug Fixes
+
+- Fix performance regression introduced in 6.8.2 with conditionals ([#63](https://github.com/babel/babylon/pull/63)) @danez
+
+## 6.8.2 (2016-06-24)
+
+### Bug Fixes
+
+- Fix parse error with yielding jsx elements in generators `function* it() { yield ; }` ([#31](https://github.com/babel/babylon/pull/31)) @eldereal
+- When cloning nodes do not clone its comments ([#24](https://github.com/babel/babylon/pull/24)) @danez
+- Fix parse errors when using arrow functions with an spread element and return type `(...props): void => {}` ([#10](https://github.com/babel/babylon/pull/10)) @danez
+- Fix leading comments added from previous node ([#23](https://github.com/babel/babylon/pull/23)) @danez
+- Fix parse errors with flow's optional arguments `(arg?) => {}` ([#19](https://github.com/babel/babylon/pull/19)) @danez
+- Support negative numeric type literals @kittens
+- Remove line terminator restriction after await keyword @kittens
+- Remove grouped type arrow restriction as it seems flow no longer has it @kittens
+- Fix parse error with generic methods that have the name `get` or `set` `class foo { get() {} }` ([#55](https://github.com/babel/babylon/pull/55)) @vkurchatkin
+- Fix parse error with arrow functions that have flow type parameter declarations `(x: T): T => x;` ([#54](https://github.com/babel/babylon/pull/54)) @gabelevi
+
+### Documentation
+
+- Document AST differences from ESTree ([#41](https://github.com/babel/babylon/pull/41)) @nene
+- Move ast spec from babel/babel ([#46](https://github.com/babel/babylon/pull/46)) @hzoo
+
+### Internal
+
+- Enable skipped tests ([#16](https://github.com/babel/babylon/pull/16)) @danez
+- Add script to test latest version of babylon with babel ([#21](https://github.com/babel/babylon/pull/21)) @danez
+- Upgrade test runner ava @kittens
+- Add missing generate-identifier-regex script @kittens
+- Rename parser context types @kittens
+- Add node v6 to travis testing @hzoo
+- Update to Unicode v9 ([#45](https://github.com/babel/babylon/pull/45)) @mathiasbynens
+
+## 6.8.1 (2016-06-06)
+
+### New Feature
+
+- Parse type parameter declarations with defaults like `type Foo = T`
+
+### Bug Fixes
+- Type parameter declarations need 1 or more type parameters.
+- The existential type `*` is not a valid type parameter.
+- The existential type `*` is a primary type
+
+### Spec Compliance
+- The param list for type parameter declarations now consists of `TypeParameter` nodes
+- New `TypeParameter` AST Node (replaces using the `Identifier` node before)
+
+```
+interface TypeParameter <: Node {
+ bound: TypeAnnotation;
+ default: TypeAnnotation;
+ name: string;
+ variance: "plus" | "minus";
+}
+```
+
+## 6.8.0 (2016-05-02)
+
+#### New Feature
+
+##### Parse Method Parameter Decorators ([#12](https://github.com/babel/babylon/pull/12))
+
+> [Method Parameter Decorators](https://goo.gl/8MmCMG) is now a TC39 [stage 0 proposal](https://github.com/tc39/ecma262/blob/master/stage0.md).
+
+Examples:
+
+```js
+class Foo {
+ constructor(@foo() x, @bar({ a: 123 }) @baz() y) {}
+}
+
+export default function func(@foo() x, @bar({ a: 123 }) @baz() y) {}
+
+var obj = {
+ method(@foo() x, @bar({ a: 123 }) @baz() y) {}
+};
+```
+
+##### Parse for-await statements (w/ `asyncGenerators` plugin) ([#17](https://github.com/babel/babylon/pull/17))
+
+There is also a new node type, `ForAwaitStatement`.
+
+> [Async generators and for-await](https://github.com/tc39/proposal-async-iteration) are now a [stage 2 proposal](https://github.com/tc39/ecma262#current-proposals).
+
+Example:
+
+```js
+async function f() {
+ for await (let x of y);
+}
+```
diff --git a/node_modules/@babel/parser/LICENSE b/node_modules/@babel/parser/LICENSE
new file mode 100644
index 000000000..d4c7fc583
--- /dev/null
+++ b/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.
diff --git a/node_modules/@babel/parser/README.md b/node_modules/@babel/parser/README.md
new file mode 100644
index 000000000..513748c37
--- /dev/null
+++ b/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
+```
diff --git a/node_modules/@babel/parser/bin/babel-parser.js b/node_modules/@babel/parser/bin/babel-parser.js
new file mode 100644
index 000000000..3aca31453
--- /dev/null
+++ b/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, " "));
+}
diff --git a/node_modules/@babel/parser/lib/index.js b/node_modules/@babel/parser/lib/index.js
new file mode 100644
index 000000000..b9559112d
--- /dev/null
+++ b/node_modules/@babel/parser/lib/index.js
@@ -0,0 +1,16051 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+class BaseParser {
+ constructor() {
+ this.sawUnambiguousESM = false;
+ this.ambiguousScriptDifferentAst = false;
+ }
+
+ hasPlugin(pluginConfig) {
+ if (typeof pluginConfig === "string") {
+ return this.plugins.has(pluginConfig);
+ } else {
+ const [pluginName, pluginOptions] = pluginConfig;
+
+ if (!this.hasPlugin(pluginName)) {
+ return false;
+ }
+
+ const actualOptions = this.plugins.get(pluginName);
+
+ for (const key of Object.keys(pluginOptions)) {
+ if ((actualOptions == null ? void 0 : actualOptions[key]) !== pluginOptions[key]) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+ }
+
+ getPluginOption(plugin, name) {
+ var _this$plugins$get;
+
+ return (_this$plugins$get = this.plugins.get(plugin)) == null ? void 0 : _this$plugins$get[name];
+ }
+
+}
+
+function setTrailingComments(node, comments) {
+ if (node.trailingComments === undefined) {
+ node.trailingComments = comments;
+ } else {
+ node.trailingComments.unshift(...comments);
+ }
+}
+
+function setLeadingComments(node, comments) {
+ if (node.leadingComments === undefined) {
+ node.leadingComments = comments;
+ } else {
+ node.leadingComments.unshift(...comments);
+ }
+}
+
+function setInnerComments(node, comments) {
+ if (node.innerComments === undefined) {
+ node.innerComments = comments;
+ } else {
+ node.innerComments.unshift(...comments);
+ }
+}
+
+function adjustInnerComments(node, elements, commentWS) {
+ let lastElement = null;
+ let i = elements.length;
+
+ while (lastElement === null && i > 0) {
+ lastElement = elements[--i];
+ }
+
+ if (lastElement === null || lastElement.start > commentWS.start) {
+ setInnerComments(node, commentWS.comments);
+ } else {
+ setTrailingComments(lastElement, commentWS.comments);
+ }
+}
+
+class CommentsParser extends BaseParser {
+ addComment(comment) {
+ if (this.filename) comment.loc.filename = this.filename;
+ this.state.comments.push(comment);
+ }
+
+ processComment(node) {
+ const {
+ commentStack
+ } = this.state;
+ const commentStackLength = commentStack.length;
+ if (commentStackLength === 0) return;
+ let i = commentStackLength - 1;
+ const lastCommentWS = commentStack[i];
+
+ if (lastCommentWS.start === node.end) {
+ lastCommentWS.leadingNode = node;
+ i--;
+ }
+
+ const {
+ start: nodeStart
+ } = node;
+
+ for (; i >= 0; i--) {
+ const commentWS = commentStack[i];
+ const commentEnd = commentWS.end;
+
+ if (commentEnd > nodeStart) {
+ commentWS.containingNode = node;
+ this.finalizeComment(commentWS);
+ commentStack.splice(i, 1);
+ } else {
+ if (commentEnd === nodeStart) {
+ commentWS.trailingNode = node;
+ }
+
+ break;
+ }
+ }
+ }
+
+ finalizeComment(commentWS) {
+ const {
+ comments
+ } = commentWS;
+
+ if (commentWS.leadingNode !== null || commentWS.trailingNode !== null) {
+ if (commentWS.leadingNode !== null) {
+ setTrailingComments(commentWS.leadingNode, comments);
+ }
+
+ if (commentWS.trailingNode !== null) {
+ setLeadingComments(commentWS.trailingNode, comments);
+ }
+ } else {
+ const {
+ containingNode: node,
+ start: commentStart
+ } = commentWS;
+
+ if (this.input.charCodeAt(commentStart - 1) === 44) {
+ switch (node.type) {
+ case "ObjectExpression":
+ case "ObjectPattern":
+ case "RecordExpression":
+ adjustInnerComments(node, node.properties, commentWS);
+ break;
+
+ case "CallExpression":
+ case "OptionalCallExpression":
+ adjustInnerComments(node, node.arguments, commentWS);
+ break;
+
+ case "FunctionDeclaration":
+ case "FunctionExpression":
+ case "ArrowFunctionExpression":
+ case "ObjectMethod":
+ case "ClassMethod":
+ case "ClassPrivateMethod":
+ adjustInnerComments(node, node.params, commentWS);
+ break;
+
+ case "ArrayExpression":
+ case "ArrayPattern":
+ case "TupleExpression":
+ adjustInnerComments(node, node.elements, commentWS);
+ break;
+
+ case "ExportNamedDeclaration":
+ case "ImportDeclaration":
+ adjustInnerComments(node, node.specifiers, commentWS);
+ break;
+
+ default:
+ {
+ setInnerComments(node, comments);
+ }
+ }
+ } else {
+ setInnerComments(node, comments);
+ }
+ }
+ }
+
+ finalizeRemainingComments() {
+ const {
+ commentStack
+ } = this.state;
+
+ for (let i = commentStack.length - 1; i >= 0; i--) {
+ this.finalizeComment(commentStack[i]);
+ }
+
+ this.state.commentStack = [];
+ }
+
+ resetPreviousNodeTrailingComments(node) {
+ const {
+ commentStack
+ } = this.state;
+ const {
+ length
+ } = commentStack;
+ if (length === 0) return;
+ const commentWS = commentStack[length - 1];
+
+ if (commentWS.leadingNode === node) {
+ commentWS.leadingNode = null;
+ }
+ }
+
+ takeSurroundingComments(node, start, end) {
+ const {
+ commentStack
+ } = this.state;
+ const commentStackLength = commentStack.length;
+ if (commentStackLength === 0) return;
+ let i = commentStackLength - 1;
+
+ for (; i >= 0; i--) {
+ const commentWS = commentStack[i];
+ const commentEnd = commentWS.end;
+ const commentStart = commentWS.start;
+
+ if (commentStart === end) {
+ commentWS.leadingNode = node;
+ } else if (commentEnd === start) {
+ commentWS.trailingNode = node;
+ } else if (commentEnd < start) {
+ break;
+ }
+ }
+ }
+
+}
+
+const ErrorCodes = Object.freeze({
+ SyntaxError: "BABEL_PARSER_SYNTAX_ERROR",
+ SourceTypeModuleError: "BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED"
+});
+
+const ErrorMessages = makeErrorTemplates({
+ 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.",
+ AwaitBindingIdentifierInStaticBlock: "Can not use 'await' as identifier inside a static block.",
+ 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: "A 'get' accesor must not have any formal parameters.",
+ BadSetterArity: "A 'set' accesor must have exactly one formal parameter.",
+ BadSetterRestParameter: "A 'set' accesor 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.",
+ 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.",
+ ForOfAsync: "The left-hand side of a for-of loop may not be 'async'.",
+ ForOfLet: "The left-hand side of a for-of loop may not start with 'let'.",
+ 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()`.",
+ IncompatibleRegExpUVFlags: "The 'u' and 'v' regular expression flags cannot be enabled at the same time.",
+ InvalidBigIntLiteral: "Invalid BigIntLiteral.",
+ InvalidCodePoint: "Code point out of bounds.",
+ InvalidCoverInitializedName: "Invalid shorthand property initializer.",
+ 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.",
+ MissingSemicolon: "Missing semicolon.",
+ 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.",
+ OverrideOnConstructor: "'override' modifier cannot appear on a constructor declaration.",
+ ParamDupe: "Argument name clash.",
+ PatternHasAccessor: "Object pattern can't contain getter or setter.",
+ PatternHasMethod: "Object pattern can't contain methods.",
+ PipeBodyIsTighter: "Unexpected %0 after pipeline body; any %0 expression acting as Hack-style pipe body must be parenthesized due to its loose operator precedence.",
+ PipeTopicRequiresHackPipes: 'Topic reference is used, but the pipelineOperator plugin was not passed a "proposal": "hack" or "smart" option.',
+ PipeTopicUnbound: "Topic reference is unbound; it must be inside a pipe body.",
+ PipeTopicUnconfiguredToken: 'Invalid topic token %0. In order to use %0 as a topic reference, the pipelineOperator plugin must be configured with { "proposal": "hack", "topicToken": "%0" }.',
+ PipeTopicUnused: "Hack-style pipe body does not contain a topic reference; Hack-style pipes must use topic at least once.",
+ PipeUnparenthesizedBody: "Hack-style pipe body cannot be an unparenthesized %0 expression; please wrap it in parentheses.",
+ 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: 'Topic reference is used, but the pipelineOperator plugin was not passed a "proposal": "hack" or "smart" 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 or class properties.",
+ UnexpectedNumericSeparator: "A numeric separator is only allowed between two digits.",
+ UnexpectedPrivateField: "Unexpected private name.",
+ 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."
+}, ErrorCodes.SyntaxError);
+const SourceTypeModuleErrorMessages = makeErrorTemplates({
+ ImportMetaOutsideModule: `import.meta may appear only with 'sourceType: "module"'`,
+ ImportOutsideModule: `'import' and 'export' may appear only with 'sourceType: "module"'`
+}, ErrorCodes.SourceTypeModuleError);
+
+function keepReasonCodeCompat(reasonCode, syntaxPlugin) {
+ {
+ if (syntaxPlugin === "flow" && reasonCode === "PatternIsOptional") {
+ return "OptionalBindingPattern";
+ }
+ }
+ return reasonCode;
+}
+
+function makeErrorTemplates(messages, code, syntaxPlugin) {
+ const templates = {};
+ Object.keys(messages).forEach(reasonCode => {
+ templates[reasonCode] = Object.freeze({
+ code,
+ reasonCode: keepReasonCodeCompat(reasonCode, syntaxPlugin),
+ template: messages[reasonCode]
+ });
+ });
+ return Object.freeze(templates);
+}
+class ParserError extends CommentsParser {
+ raise({
+ code,
+ reasonCode,
+ template
+ }, origin, ...params) {
+ return this.raiseWithData(origin.node ? origin.node.loc.start : origin.at, {
+ code,
+ reasonCode
+ }, template, ...params);
+ }
+
+ raiseOverwrite(loc, {
+ code,
+ template
+ }, ...params) {
+ const pos = loc.index;
+ const message = template.replace(/%(\d+)/g, (_, i) => params[i]) + ` (${loc.line}:${loc.column})`;
+
+ if (this.options.errorRecovery) {
+ const errors = this.state.errors;
+
+ for (let i = errors.length - 1; i >= 0; i--) {
+ const error = errors[i];
+
+ if (error.pos === pos) {
+ return Object.assign(error, {
+ message
+ });
+ } else if (error.pos < pos) {
+ break;
+ }
+ }
+ }
+
+ return this._raise({
+ code,
+ loc,
+ pos
+ }, message);
+ }
+
+ raiseWithData(loc, data, errorTemplate, ...params) {
+ const pos = loc.index;
+ 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;
+ }
+ }
+
+}
+
+const {
+ defineProperty
+} = Object;
+
+const toUnenumerable = (object, key) => defineProperty(object, key, {
+ enumerable: false,
+ value: object[key]
+});
+
+function toESTreeLocation(node) {
+ toUnenumerable(node.loc.start, "index");
+ toUnenumerable(node.loc.end, "index");
+ return node;
+}
+
+var estree = (superClass => class extends superClass {
+ parse() {
+ const file = toESTreeLocation(super.parse());
+
+ if (this.options.tokens) {
+ file.tokens = file.tokens.map(toESTreeLocation);
+ }
+
+ return file;
+ }
+
+ parseRegExpLiteral({
+ pattern,
+ flags
+ }) {
+ let regex = null;
+
+ try {
+ regex = new RegExp(pattern, flags);
+ } catch (e) {}
+
+ const node = this.estreeParseLiteral(regex);
+ node.regex = {
+ pattern,
+ flags
+ };
+ return node;
+ }
+
+ parseBigIntLiteral(value) {
+ let bigInt;
+
+ try {
+ bigInt = BigInt(value);
+ } catch (_unused) {
+ bigInt = null;
+ }
+
+ const node = this.estreeParseLiteral(bigInt);
+ node.bigint = String(node.value || value);
+ return node;
+ }
+
+ parseDecimalLiteral(value) {
+ const decimal = null;
+ const node = this.estreeParseLiteral(decimal);
+ node.decimal = String(node.value || value);
+ return node;
+ }
+
+ estreeParseLiteral(value) {
+ return this.parseLiteral(value, "Literal");
+ }
+
+ parseStringLiteral(value) {
+ return this.estreeParseLiteral(value);
+ }
+
+ parseNumericLiteral(value) {
+ return this.estreeParseLiteral(value);
+ }
+
+ parseNullLiteral() {
+ return this.estreeParseLiteral(null);
+ }
+
+ parseBooleanLiteral(value) {
+ return this.estreeParseLiteral(value);
+ }
+
+ 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.extra.expressionValue;
+ expression.raw = directiveLiteral.extra.raw;
+ stmt.expression = this.finishNodeAt(expression, "Literal", directiveLiteral.loc.end);
+ stmt.directive = directiveLiteral.extra.raw.slice(1, -1);
+ return this.finishNodeAt(stmt, "ExpressionStatement", directive.loc.end);
+ }
+
+ initFunction(node, isAsync) {
+ super.initFunction(node, isAsync);
+ node.expression = false;
+ }
+
+ checkDeclaration(node) {
+ if (node != null && this.isObjectProperty(node)) {
+ this.checkDeclaration(node.value);
+ } else {
+ super.checkDeclaration(node);
+ }
+ }
+
+ getObjectOrClassMethodParams(method) {
+ return method.value.params;
+ }
+
+ isValidDirective(stmt) {
+ var _stmt$expression$extr;
+
+ return stmt.type === "ExpressionStatement" && stmt.expression.type === "Literal" && typeof stmt.expression.value === "string" && !((_stmt$expression$extr = stmt.expression.extra) != null && _stmt$expression$extr.parenthesized);
+ }
+
+ parseBlockBody(node, ...args) {
+ super.parseBlockBody(node, ...args);
+ 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);
+ }
+
+ parsePrivateName() {
+ const node = super.parsePrivateName();
+ {
+ if (!this.getPluginOption("estree", "classFeatures")) {
+ return node;
+ }
+ }
+ return this.convertPrivateNameToPrivateIdentifier(node);
+ }
+
+ convertPrivateNameToPrivateIdentifier(node) {
+ const name = super.getPrivateNameSV(node);
+ node = node;
+ delete node.id;
+ node.name = name;
+ node.type = "PrivateIdentifier";
+ return node;
+ }
+
+ isPrivateName(node) {
+ {
+ if (!this.getPluginOption("estree", "classFeatures")) {
+ return super.isPrivateName(node);
+ }
+ }
+ return node.type === "PrivateIdentifier";
+ }
+
+ getPrivateNameSV(node) {
+ {
+ if (!this.getPluginOption("estree", "classFeatures")) {
+ return super.getPrivateNameSV(node);
+ }
+ }
+ return node.name;
+ }
+
+ parseLiteral(value, type) {
+ const node = super.parseLiteral(value, type);
+ 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;
+
+ if (type === "ClassPrivateMethod") {
+ node.computed = false;
+ }
+
+ type = "MethodDefinition";
+ return this.finishNode(node, type);
+ }
+
+ parseClassProperty(...args) {
+ const propertyNode = super.parseClassProperty(...args);
+ {
+ if (!this.getPluginOption("estree", "classFeatures")) {
+ return propertyNode;
+ }
+ }
+ propertyNode.type = "PropertyDefinition";
+ return propertyNode;
+ }
+
+ parseClassPrivateProperty(...args) {
+ const propertyNode = super.parseClassPrivateProperty(...args);
+ {
+ if (!this.getPluginOption("estree", "classFeatures")) {
+ return propertyNode;
+ }
+ }
+ propertyNode.type = "PropertyDefinition";
+ propertyNode.computed = false;
+ return propertyNode;
+ }
+
+ 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;
+ }
+
+ isAssignable(node, isBinding) {
+ if (node != null && this.isObjectProperty(node)) {
+ return this.isAssignable(node.value, isBinding);
+ }
+
+ return super.isAssignable(node, isBinding);
+ }
+
+ toAssignable(node, isLHS = false) {
+ if (node != null && this.isObjectProperty(node)) {
+ const {
+ key,
+ value
+ } = node;
+
+ if (this.isPrivateName(key)) {
+ this.classScope.usePrivateName(this.getPrivateNameSV(key), key.loc.start);
+ }
+
+ this.toAssignable(value, isLHS);
+ return node;
+ }
+
+ return super.toAssignable(node, isLHS);
+ }
+
+ toAssignableObjectExpressionProp(prop, ...args) {
+ if (prop.kind === "get" || prop.kind === "set") {
+ this.raise(ErrorMessages.PatternHasAccessor, {
+ node: prop.key
+ });
+ } else if (prop.method) {
+ this.raise(ErrorMessages.PatternHasMethod, {
+ node: prop.key
+ });
+ } else {
+ super.toAssignableObjectExpressionProp(prop, ...args);
+ }
+ }
+
+ finishCallExpression(node, optional) {
+ super.finishCallExpression(node, optional);
+
+ if (node.callee.type === "Import") {
+ node.type = "ImportExpression";
+ node.source = node.arguments[0];
+
+ if (this.hasPlugin("importAssertions")) {
+ var _node$arguments$;
+
+ node.attributes = (_node$arguments$ = node.arguments[1]) != null ? _node$arguments$ : null;
+ }
+
+ 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;
+ }
+
+ hasPropertyAsPrivateName(node) {
+ if (node.type === "ChainExpression") {
+ node = node.expression;
+ }
+
+ return super.hasPropertyAsPrivateName(node);
+ }
+
+ isOptionalChain(node) {
+ return node.type === "ChainExpression";
+ }
+
+ isObjectProperty(node) {
+ return node.type === "Property" && node.kind === "init" && !node.method;
+ }
+
+ isObjectMethod(node) {
+ return node.method || node.kind === "get" || node.kind === "set";
+ }
+
+ finishNodeAt(node, type, endLoc) {
+ return toESTreeLocation(super.finishNodeAt(node, type, endLoc));
+ }
+
+ resetEndLocation(node, endLoc = this.state.lastTokEndLoc) {
+ super.resetEndLocation(node, endLoc);
+ toESTreeLocation(node);
+ }
+
+});
+
+class TokContext {
+ constructor(token, preserveSpace) {
+ this.token = void 0;
+ this.preserveSpace = void 0;
+ this.token = token;
+ this.preserveSpace = !!preserveSpace;
+ }
+
+}
+const types = {
+ brace: new TokContext("{"),
+ j_oTag: new TokContext("...", true)
+};
+{
+ types.template = new TokContext("`", true);
+}
+
+const beforeExpr = true;
+const startsExpr = true;
+const isLoop = true;
+const isAssign = true;
+const prefix = true;
+const postfix = true;
+class ExportedTokenType {
+ 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.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;
+ }
+ }
+
+}
+const keywords$1 = new Map();
+
+function createKeyword(name, options = {}) {
+ options.keyword = name;
+ const token = createToken(name, options);
+ keywords$1.set(name, token);
+ return token;
+}
+
+function createBinop(name, binop) {
+ return createToken(name, {
+ beforeExpr,
+ binop
+ });
+}
+
+let tokenTypeCounter = -1;
+const tokenTypes = [];
+const tokenLabels = [];
+const tokenBinops = [];
+const tokenBeforeExprs = [];
+const tokenStartsExprs = [];
+const tokenPrefixes = [];
+
+function createToken(name, options = {}) {
+ var _options$binop, _options$beforeExpr, _options$startsExpr, _options$prefix;
+
+ ++tokenTypeCounter;
+ tokenLabels.push(name);
+ tokenBinops.push((_options$binop = options.binop) != null ? _options$binop : -1);
+ tokenBeforeExprs.push((_options$beforeExpr = options.beforeExpr) != null ? _options$beforeExpr : false);
+ tokenStartsExprs.push((_options$startsExpr = options.startsExpr) != null ? _options$startsExpr : false);
+ tokenPrefixes.push((_options$prefix = options.prefix) != null ? _options$prefix : false);
+ tokenTypes.push(new ExportedTokenType(name, options));
+ return tokenTypeCounter;
+}
+
+function createKeywordLike(name, options = {}) {
+ var _options$binop2, _options$beforeExpr2, _options$startsExpr2, _options$prefix2;
+
+ ++tokenTypeCounter;
+ keywords$1.set(name, tokenTypeCounter);
+ tokenLabels.push(name);
+ tokenBinops.push((_options$binop2 = options.binop) != null ? _options$binop2 : -1);
+ tokenBeforeExprs.push((_options$beforeExpr2 = options.beforeExpr) != null ? _options$beforeExpr2 : false);
+ tokenStartsExprs.push((_options$startsExpr2 = options.startsExpr) != null ? _options$startsExpr2 : false);
+ tokenPrefixes.push((_options$prefix2 = options.prefix) != null ? _options$prefix2 : false);
+ tokenTypes.push(new ExportedTokenType("name", options));
+ return tokenTypeCounter;
+}
+
+const tt = {
+ bracketL: createToken("[", {
+ beforeExpr,
+ startsExpr
+ }),
+ bracketHashL: createToken("#[", {
+ beforeExpr,
+ startsExpr
+ }),
+ bracketBarL: createToken("[|", {
+ beforeExpr,
+ startsExpr
+ }),
+ bracketR: createToken("]"),
+ bracketBarR: createToken("|]"),
+ braceL: createToken("{", {
+ beforeExpr,
+ startsExpr
+ }),
+ braceBarL: createToken("{|", {
+ beforeExpr,
+ startsExpr
+ }),
+ braceHashL: createToken("#{", {
+ beforeExpr,
+ startsExpr
+ }),
+ braceR: createToken("}", {
+ beforeExpr
+ }),
+ braceBarR: createToken("|}"),
+ parenL: createToken("(", {
+ beforeExpr,
+ startsExpr
+ }),
+ parenR: createToken(")"),
+ comma: createToken(",", {
+ beforeExpr
+ }),
+ semi: createToken(";", {
+ beforeExpr
+ }),
+ colon: createToken(":", {
+ beforeExpr
+ }),
+ doubleColon: createToken("::", {
+ beforeExpr
+ }),
+ dot: createToken("."),
+ question: createToken("?", {
+ beforeExpr
+ }),
+ questionDot: createToken("?."),
+ arrow: createToken("=>", {
+ beforeExpr
+ }),
+ template: createToken("template"),
+ ellipsis: createToken("...", {
+ beforeExpr
+ }),
+ backQuote: createToken("`", {
+ startsExpr
+ }),
+ dollarBraceL: createToken("${", {
+ beforeExpr,
+ startsExpr
+ }),
+ templateTail: createToken("...`", {
+ startsExpr
+ }),
+ templateNonTail: createToken("...${", {
+ beforeExpr,
+ startsExpr
+ }),
+ at: createToken("@"),
+ hash: createToken("#", {
+ startsExpr
+ }),
+ interpreterDirective: createToken("#!..."),
+ eq: createToken("=", {
+ beforeExpr,
+ isAssign
+ }),
+ assign: createToken("_=", {
+ beforeExpr,
+ isAssign
+ }),
+ slashAssign: createToken("_=", {
+ beforeExpr,
+ isAssign
+ }),
+ xorAssign: createToken("_=", {
+ beforeExpr,
+ isAssign
+ }),
+ moduloAssign: createToken("_=", {
+ beforeExpr,
+ isAssign
+ }),
+ incDec: createToken("++/--", {
+ prefix,
+ postfix,
+ startsExpr
+ }),
+ bang: createToken("!", {
+ beforeExpr,
+ prefix,
+ startsExpr
+ }),
+ tilde: createToken("~", {
+ beforeExpr,
+ prefix,
+ startsExpr
+ }),
+ doubleCaret: createToken("^^", {
+ startsExpr
+ }),
+ doubleAt: createToken("@@", {
+ 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),
+ lt: createBinop("/<=/>=", 7),
+ gt: createBinop("/<=/>=", 7),
+ relational: createBinop("/<=/>=", 7),
+ bitShift: createBinop("<>/>>>", 8),
+ bitShiftL: createBinop("<>/>>>", 8),
+ bitShiftR: createBinop("<>/>>>", 8),
+ plusMin: createToken("+/-", {
+ beforeExpr,
+ binop: 9,
+ prefix,
+ startsExpr
+ }),
+ modulo: createToken("%", {
+ binop: 10,
+ startsExpr
+ }),
+ star: createToken("*", {
+ binop: 10
+ }),
+ slash: createBinop("/", 10),
+ exponent: createToken("**", {
+ beforeExpr,
+ binop: 11,
+ rightAssociative: true
+ }),
+ _in: createKeyword("in", {
+ beforeExpr,
+ binop: 7
+ }),
+ _instanceof: createKeyword("instanceof", {
+ beforeExpr,
+ binop: 7
+ }),
+ _break: createKeyword("break"),
+ _case: createKeyword("case", {
+ beforeExpr
+ }),
+ _catch: createKeyword("catch"),
+ _continue: createKeyword("continue"),
+ _debugger: createKeyword("debugger"),
+ _default: createKeyword("default", {
+ beforeExpr
+ }),
+ _else: createKeyword("else", {
+ beforeExpr
+ }),
+ _finally: createKeyword("finally"),
+ _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"),
+ _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
+ }),
+ _typeof: createKeyword("typeof", {
+ beforeExpr,
+ prefix,
+ startsExpr
+ }),
+ _void: createKeyword("void", {
+ beforeExpr,
+ prefix,
+ startsExpr
+ }),
+ _delete: createKeyword("delete", {
+ beforeExpr,
+ prefix,
+ startsExpr
+ }),
+ _do: createKeyword("do", {
+ isLoop,
+ beforeExpr
+ }),
+ _for: createKeyword("for", {
+ isLoop
+ }),
+ _while: createKeyword("while", {
+ isLoop
+ }),
+ _as: createKeywordLike("as", {
+ startsExpr
+ }),
+ _assert: createKeywordLike("assert", {
+ startsExpr
+ }),
+ _async: createKeywordLike("async", {
+ startsExpr
+ }),
+ _await: createKeywordLike("await", {
+ startsExpr
+ }),
+ _from: createKeywordLike("from", {
+ startsExpr
+ }),
+ _get: createKeywordLike("get", {
+ startsExpr
+ }),
+ _let: createKeywordLike("let", {
+ startsExpr
+ }),
+ _meta: createKeywordLike("meta", {
+ startsExpr
+ }),
+ _of: createKeywordLike("of", {
+ startsExpr
+ }),
+ _sent: createKeywordLike("sent", {
+ startsExpr
+ }),
+ _set: createKeywordLike("set", {
+ startsExpr
+ }),
+ _static: createKeywordLike("static", {
+ startsExpr
+ }),
+ _yield: createKeywordLike("yield", {
+ startsExpr
+ }),
+ _asserts: createKeywordLike("asserts", {
+ startsExpr
+ }),
+ _checks: createKeywordLike("checks", {
+ startsExpr
+ }),
+ _exports: createKeywordLike("exports", {
+ startsExpr
+ }),
+ _global: createKeywordLike("global", {
+ startsExpr
+ }),
+ _implements: createKeywordLike("implements", {
+ startsExpr
+ }),
+ _intrinsic: createKeywordLike("intrinsic", {
+ startsExpr
+ }),
+ _infer: createKeywordLike("infer", {
+ startsExpr
+ }),
+ _is: createKeywordLike("is", {
+ startsExpr
+ }),
+ _mixins: createKeywordLike("mixins", {
+ startsExpr
+ }),
+ _proto: createKeywordLike("proto", {
+ startsExpr
+ }),
+ _require: createKeywordLike("require", {
+ startsExpr
+ }),
+ _keyof: createKeywordLike("keyof", {
+ startsExpr
+ }),
+ _readonly: createKeywordLike("readonly", {
+ startsExpr
+ }),
+ _unique: createKeywordLike("unique", {
+ startsExpr
+ }),
+ _abstract: createKeywordLike("abstract", {
+ startsExpr
+ }),
+ _declare: createKeywordLike("declare", {
+ startsExpr
+ }),
+ _enum: createKeywordLike("enum", {
+ startsExpr
+ }),
+ _module: createKeywordLike("module", {
+ startsExpr
+ }),
+ _namespace: createKeywordLike("namespace", {
+ startsExpr
+ }),
+ _interface: createKeywordLike("interface", {
+ startsExpr
+ }),
+ _type: createKeywordLike("type", {
+ startsExpr
+ }),
+ _opaque: createKeywordLike("opaque", {
+ startsExpr
+ }),
+ name: createToken("name", {
+ startsExpr
+ }),
+ string: createToken("string", {
+ startsExpr
+ }),
+ num: createToken("num", {
+ startsExpr
+ }),
+ bigint: createToken("bigint", {
+ startsExpr
+ }),
+ decimal: createToken("decimal", {
+ startsExpr
+ }),
+ regexp: createToken("regexp", {
+ startsExpr
+ }),
+ privateName: createToken("#name", {
+ startsExpr
+ }),
+ eof: createToken("eof"),
+ jsxName: createToken("jsxName"),
+ jsxText: createToken("jsxText", {
+ beforeExpr: true
+ }),
+ jsxTagStart: createToken("jsxTagStart", {
+ startsExpr: true
+ }),
+ jsxTagEnd: createToken("jsxTagEnd"),
+ placeholder: createToken("%%", {
+ startsExpr: true
+ })
+};
+function tokenIsIdentifier(token) {
+ return token >= 93 && token <= 128;
+}
+function tokenKeywordOrIdentifierIsKeyword(token) {
+ return token <= 92;
+}
+function tokenIsKeywordOrIdentifier(token) {
+ return token >= 58 && token <= 128;
+}
+function tokenIsLiteralPropertyName(token) {
+ return token >= 58 && token <= 132;
+}
+function tokenComesBeforeExpression(token) {
+ return tokenBeforeExprs[token];
+}
+function tokenCanStartExpression(token) {
+ return tokenStartsExprs[token];
+}
+function tokenIsAssignment(token) {
+ return token >= 29 && token <= 33;
+}
+function tokenIsFlowInterfaceOrTypeOrOpaque(token) {
+ return token >= 125 && token <= 127;
+}
+function tokenIsLoop(token) {
+ return token >= 90 && token <= 92;
+}
+function tokenIsKeyword(token) {
+ return token >= 58 && token <= 92;
+}
+function tokenIsOperator(token) {
+ return token >= 39 && token <= 59;
+}
+function tokenIsPostfix(token) {
+ return token === 34;
+}
+function tokenIsPrefix(token) {
+ return tokenPrefixes[token];
+}
+function tokenIsTSTypeOperator(token) {
+ return token >= 117 && token <= 119;
+}
+function tokenIsTSDeclarationStart(token) {
+ return token >= 120 && token <= 126;
+}
+function tokenLabelName(token) {
+ return tokenLabels[token];
+}
+function tokenOperatorPrecedence(token) {
+ return tokenBinops[token];
+}
+function tokenIsRightAssociative(token) {
+ return token === 57;
+}
+function tokenIsTemplate(token) {
+ return token >= 24 && token <= 25;
+}
+function getExportedToken(token) {
+ return tokenTypes[token];
+}
+{
+ tokenTypes[8].updateContext = context => {
+ context.pop();
+ };
+
+ tokenTypes[5].updateContext = tokenTypes[7].updateContext = tokenTypes[23].updateContext = context => {
+ context.push(types.brace);
+ };
+
+ tokenTypes[22].updateContext = context => {
+ if (context[context.length - 1] === types.template) {
+ context.pop();
+ } else {
+ context.push(types.template);
+ }
+ };
+
+ tokenTypes[138].updateContext = context => {
+ context.push(types.j_expr, types.j_oTag);
+ };
+}
+
+class Position {
+ constructor(line, col, index) {
+ this.line = void 0;
+ this.column = void 0;
+ this.index = void 0;
+ this.line = line;
+ this.column = col;
+ this.index = index;
+ }
+
+}
+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;
+ }
+
+}
+function createPositionWithColumnOffset(position, columnOffset) {
+ const {
+ line,
+ column,
+ index
+ } = position;
+ return new Position(line, column + columnOffset, index + columnOffset);
+}
+
+let nonASCIIidentifierStartChars = "\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u037f\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u052f\u0531-\u0556\u0559\u0560-\u0588\u05d0-\u05ea\u05ef-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u0860-\u086a\u0870-\u0887\u0889-\u088e\u08a0-\u08c9\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u09fc\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0af9\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3d\u0c58-\u0c5a\u0c5d\u0c60\u0c61\u0c80\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cdd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d04-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d54-\u0d56\u0d5f-\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f5\u13f8-\u13fd\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f8\u1700-\u1711\u171f-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1878\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191e\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4c\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1c80-\u1c88\u1c90-\u1cba\u1cbd-\u1cbf\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5\u1cf6\u1cfa\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2118-\u211d\u2124\u2126\u2128\u212a-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309b-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312f\u3131-\u318e\u31a0-\u31bf\u31f0-\u31ff\u3400-\u4dbf\u4e00-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua69d\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua7ca\ua7d0\ua7d1\ua7d3\ua7d5-\ua7d9\ua7f2-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua8fd\ua8fe\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\ua9e0-\ua9e4\ua9e6-\ua9ef\ua9fa-\ua9fe\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa7e-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab5a\uab5c-\uab69\uab70-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc";
+let nonASCIIidentifierChars = "\u200c\u200d\xb7\u0300-\u036f\u0387\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u0669\u0670\u06d6-\u06dc\u06df-\u06e4\u06e7\u06e8\u06ea-\u06ed\u06f0-\u06f9\u0711\u0730-\u074a\u07a6-\u07b0\u07c0-\u07c9\u07eb-\u07f3\u07fd\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0859-\u085b\u0898-\u089f\u08ca-\u08e1\u08e3-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09cb-\u09cd\u09d7\u09e2\u09e3\u09e6-\u09ef\u09fe\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2\u0ae3\u0ae6-\u0aef\u0afa-\u0aff\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b55-\u0b57\u0b62\u0b63\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c00-\u0c04\u0c3c\u0c3e-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0c66-\u0c6f\u0c81-\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0ce6-\u0cef\u0d00-\u0d03\u0d3b\u0d3c\u0d3e-\u0d44\u0d46-\u0d48\u0d4a-\u0d4d\u0d57\u0d62\u0d63\u0d66-\u0d6f\u0d81-\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2\u0df3\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0e50-\u0e59\u0eb1\u0eb4-\u0ebc\u0ec8-\u0ecd\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e\u0f3f\u0f71-\u0f84\u0f86\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u102b-\u103e\u1040-\u1049\u1056-\u1059\u105e-\u1060\u1062-\u1064\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u1369-\u1371\u1712-\u1715\u1732-\u1734\u1752\u1753\u1772\u1773\u17b4-\u17d3\u17dd\u17e0-\u17e9\u180b-\u180d\u180f-\u1819\u18a9\u1920-\u192b\u1930-\u193b\u1946-\u194f\u19d0-\u19da\u1a17-\u1a1b\u1a55-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1ab0-\u1abd\u1abf-\u1ace\u1b00-\u1b04\u1b34-\u1b44\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1b82\u1ba1-\u1bad\u1bb0-\u1bb9\u1be6-\u1bf3\u1c24-\u1c37\u1c40-\u1c49\u1c50-\u1c59\u1cd0-\u1cd2\u1cd4-\u1ce8\u1ced\u1cf4\u1cf7-\u1cf9\u1dc0-\u1dff\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2cef-\u2cf1\u2d7f\u2de0-\u2dff\u302a-\u302f\u3099\u309a\ua620-\ua629\ua66f\ua674-\ua67d\ua69e\ua69f\ua6f0\ua6f1\ua802\ua806\ua80b\ua823-\ua827\ua82c\ua880\ua881\ua8b4-\ua8c5\ua8d0-\ua8d9\ua8e0-\ua8f1\ua8ff-\ua909\ua926-\ua92d\ua947-\ua953\ua980-\ua983\ua9b3-\ua9c0\ua9d0-\ua9d9\ua9e5\ua9f0-\ua9f9\uaa29-\uaa36\uaa43\uaa4c\uaa4d\uaa50-\uaa59\uaa7b-\uaa7d\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uaaeb-\uaaef\uaaf5\uaaf6\uabe3-\uabea\uabec\uabed\uabf0-\uabf9\ufb1e\ufe00-\ufe0f\ufe20-\ufe2f\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f";
+const nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
+const nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
+nonASCIIidentifierStartChars = nonASCIIidentifierChars = null;
+const astralIdentifierStartCodes = [0, 11, 2, 25, 2, 18, 2, 1, 2, 14, 3, 13, 35, 122, 70, 52, 268, 28, 4, 48, 48, 31, 14, 29, 6, 37, 11, 29, 3, 35, 5, 7, 2, 4, 43, 157, 19, 35, 5, 35, 5, 39, 9, 51, 13, 10, 2, 14, 2, 6, 2, 1, 2, 10, 2, 14, 2, 6, 2, 1, 68, 310, 10, 21, 11, 7, 25, 5, 2, 41, 2, 8, 70, 5, 3, 0, 2, 43, 2, 1, 4, 0, 3, 22, 11, 22, 10, 30, 66, 18, 2, 1, 11, 21, 11, 25, 71, 55, 7, 1, 65, 0, 16, 3, 2, 2, 2, 28, 43, 28, 4, 28, 36, 7, 2, 27, 28, 53, 11, 21, 11, 18, 14, 17, 111, 72, 56, 50, 14, 50, 14, 35, 349, 41, 7, 1, 79, 28, 11, 0, 9, 21, 43, 17, 47, 20, 28, 22, 13, 52, 58, 1, 3, 0, 14, 44, 33, 24, 27, 35, 30, 0, 3, 0, 9, 34, 4, 0, 13, 47, 15, 3, 22, 0, 2, 0, 36, 17, 2, 24, 85, 6, 2, 0, 2, 3, 2, 14, 2, 9, 8, 46, 39, 7, 3, 1, 3, 21, 2, 6, 2, 1, 2, 4, 4, 0, 19, 0, 13, 4, 159, 52, 19, 3, 21, 2, 31, 47, 21, 1, 2, 0, 185, 46, 42, 3, 37, 47, 21, 0, 60, 42, 14, 0, 72, 26, 38, 6, 186, 43, 117, 63, 32, 7, 3, 0, 3, 7, 2, 1, 2, 23, 16, 0, 2, 0, 95, 7, 3, 38, 17, 0, 2, 0, 29, 0, 11, 39, 8, 0, 22, 0, 12, 45, 20, 0, 19, 72, 264, 8, 2, 36, 18, 0, 50, 29, 113, 6, 2, 1, 2, 37, 22, 0, 26, 5, 2, 1, 2, 31, 15, 0, 328, 18, 190, 0, 80, 921, 103, 110, 18, 195, 2637, 96, 16, 1070, 4050, 582, 8634, 568, 8, 30, 18, 78, 18, 29, 19, 47, 17, 3, 32, 20, 6, 18, 689, 63, 129, 74, 6, 0, 67, 12, 65, 1, 2, 0, 29, 6135, 9, 1237, 43, 8, 8936, 3, 2, 6, 2, 1, 2, 290, 46, 2, 18, 3, 9, 395, 2309, 106, 6, 12, 4, 8, 8, 9, 5991, 84, 2, 70, 2, 1, 3, 0, 3, 1, 3, 3, 2, 11, 2, 0, 2, 6, 2, 64, 2, 3, 3, 7, 2, 6, 2, 27, 2, 3, 2, 4, 2, 0, 4, 6, 2, 339, 3, 24, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 7, 1845, 30, 482, 44, 11, 6, 17, 0, 322, 29, 19, 43, 1269, 6, 2, 3, 2, 1, 2, 14, 2, 196, 60, 67, 8, 0, 1205, 3, 2, 26, 2, 1, 2, 0, 3, 0, 2, 9, 2, 3, 2, 0, 2, 0, 7, 0, 5, 0, 2, 0, 2, 0, 2, 2, 2, 1, 2, 0, 3, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 1, 2, 0, 3, 3, 2, 6, 2, 3, 2, 3, 2, 0, 2, 9, 2, 16, 6, 2, 2, 4, 2, 16, 4421, 42719, 33, 4152, 8, 221, 3, 5761, 15, 7472, 3104, 541, 1507, 4938];
+const astralIdentifierCodes = [509, 0, 227, 0, 150, 4, 294, 9, 1368, 2, 2, 1, 6, 3, 41, 2, 5, 0, 166, 1, 574, 3, 9, 9, 370, 1, 154, 10, 50, 3, 123, 2, 54, 14, 32, 10, 3, 1, 11, 3, 46, 10, 8, 0, 46, 9, 7, 2, 37, 13, 2, 9, 6, 1, 45, 0, 13, 2, 49, 13, 9, 3, 2, 11, 83, 11, 7, 0, 161, 11, 6, 9, 7, 3, 56, 1, 2, 6, 3, 1, 3, 2, 10, 0, 11, 1, 3, 6, 4, 4, 193, 17, 10, 9, 5, 0, 82, 19, 13, 9, 214, 6, 3, 8, 28, 1, 83, 16, 16, 9, 82, 12, 9, 9, 84, 14, 5, 9, 243, 14, 166, 9, 71, 5, 2, 1, 3, 3, 2, 0, 2, 1, 13, 9, 120, 6, 3, 6, 4, 0, 29, 9, 41, 6, 2, 3, 9, 0, 10, 10, 47, 15, 406, 7, 2, 7, 17, 9, 57, 21, 2, 13, 123, 5, 4, 0, 2, 1, 2, 6, 2, 0, 9, 9, 49, 4, 2, 1, 2, 4, 9, 9, 330, 3, 19306, 9, 87, 9, 39, 4, 60, 6, 26, 9, 1014, 0, 2, 54, 8, 3, 82, 0, 12, 1, 19628, 1, 4706, 45, 3, 22, 543, 4, 4, 5, 9, 7, 3, 6, 31, 3, 149, 2, 1418, 49, 513, 54, 5, 49, 9, 0, 15, 0, 23, 4, 2, 14, 1361, 6, 2, 16, 3, 6, 2, 1, 2, 4, 262, 6, 10, 9, 357, 0, 62, 13, 1495, 6, 110, 6, 6, 9, 4759, 9, 787719, 239];
+
+function isInAstralSet(code, set) {
+ let pos = 0x10000;
+
+ for (let i = 0, length = set.length; i < length; i += 2) {
+ pos += set[i];
+ if (pos > code) return false;
+ pos += set[i + 1];
+ if (pos >= code) return true;
+ }
+
+ return false;
+}
+
+function isIdentifierStart(code) {
+ if (code < 65) return code === 36;
+ if (code <= 90) return true;
+ if (code < 97) return code === 95;
+ if (code <= 122) return true;
+
+ if (code <= 0xffff) {
+ return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code));
+ }
+
+ return isInAstralSet(code, astralIdentifierStartCodes);
+}
+function isIdentifierChar(code) {
+ if (code < 48) return code === 36;
+ if (code < 58) return true;
+ if (code < 65) return false;
+ if (code <= 90) return true;
+ if (code < 97) return code === 95;
+ if (code <= 122) return true;
+
+ if (code <= 0xffff) {
+ return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));
+ }
+
+ return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes);
+}
+
+const reservedWords = {
+ keyword: ["break", "case", "catch", "continue", "debugger", "default", "do", "else", "finally", "for", "function", "if", "return", "switch", "throw", "try", "var", "const", "while", "with", "new", "this", "super", "class", "extends", "export", "import", "null", "true", "false", "in", "instanceof", "typeof", "void", "delete"],
+ strict: ["implements", "interface", "let", "package", "private", "protected", "public", "static", "yield"],
+ strictBind: ["eval", "arguments"]
+};
+const keywords = new Set(reservedWords.keyword);
+const reservedWordsStrictSet = new Set(reservedWords.strict);
+const reservedWordsStrictBindSet = new Set(reservedWords.strictBind);
+function isReservedWord(word, inModule) {
+ return inModule && word === "await" || word === "enum";
+}
+function isStrictReservedWord(word, inModule) {
+ return isReservedWord(word, inModule) || reservedWordsStrictSet.has(word);
+}
+function isStrictBindOnlyReservedWord(word) {
+ return reservedWordsStrictBindSet.has(word);
+}
+function isStrictBindReservedWord(word, inModule) {
+ return isStrictReservedWord(word, inModule) || isStrictBindOnlyReservedWord(word);
+}
+function isKeyword(word) {
+ return keywords.has(word);
+}
+
+function isIteratorStart(current, next, next2) {
+ return current === 64 && next === 64 && isIdentifierStart(next2);
+}
+const reservedWordLikeSet = new Set(["break", "case", "catch", "continue", "debugger", "default", "do", "else", "finally", "for", "function", "if", "return", "switch", "throw", "try", "var", "const", "while", "with", "new", "this", "super", "class", "extends", "export", "import", "null", "true", "false", "in", "instanceof", "typeof", "void", "delete", "implements", "interface", "let", "package", "private", "protected", "public", "static", "yield", "eval", "arguments", "enum", "await"]);
+function canBeReservedWord(word) {
+ return reservedWordLikeSet.has(word);
+}
+
+const SCOPE_OTHER = 0b000000000,
+ SCOPE_PROGRAM = 0b000000001,
+ SCOPE_FUNCTION = 0b000000010,
+ SCOPE_ARROW = 0b000000100,
+ SCOPE_SIMPLE_CATCH = 0b000001000,
+ SCOPE_SUPER = 0b000010000,
+ SCOPE_DIRECT_SUPER = 0b000100000,
+ SCOPE_CLASS = 0b001000000,
+ SCOPE_STATIC_BLOCK = 0b010000000,
+ SCOPE_TS_MODULE = 0b100000000,
+ SCOPE_VAR = SCOPE_PROGRAM | SCOPE_FUNCTION | SCOPE_TS_MODULE;
+const BIND_KIND_VALUE = 0b000000000001,
+ BIND_KIND_TYPE = 0b000000000010,
+ BIND_SCOPE_VAR = 0b000000000100,
+ BIND_SCOPE_LEXICAL = 0b000000001000,
+ BIND_SCOPE_FUNCTION = 0b000000010000,
+ BIND_FLAGS_NONE = 0b000001000000,
+ BIND_FLAGS_CLASS = 0b000010000000,
+ BIND_FLAGS_TS_ENUM = 0b000100000000,
+ BIND_FLAGS_TS_CONST_ENUM = 0b001000000000,
+ BIND_FLAGS_TS_EXPORT_ONLY = 0b010000000000,
+ BIND_FLAGS_FLOW_DECLARE_FN = 0b100000000000;
+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,
+ BIND_FLOW_DECLARE_FN = BIND_FLAGS_FLOW_DECLARE_FN;
+const CLASS_ELEMENT_FLAG_STATIC = 0b100,
+ CLASS_ELEMENT_KIND_GETTER = 0b010,
+ CLASS_ELEMENT_KIND_SETTER = 0b001,
+ CLASS_ELEMENT_KIND_ACCESSOR = CLASS_ELEMENT_KIND_GETTER | CLASS_ELEMENT_KIND_SETTER;
+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;
+
+class Scope {
+ constructor(flags) {
+ this.var = new Set();
+ this.lexical = new Set();
+ this.functions = new Set();
+ this.flags = flags;
+ }
+
+}
+class ScopeHandler {
+ constructor(raise, inModule) {
+ this.scopeStack = [];
+ this.undefinedExports = new Map();
+ this.raise = raise;
+ this.inModule = inModule;
+ }
+
+ get inFunction() {
+ return (this.currentVarScopeFlags() & SCOPE_FUNCTION) > 0;
+ }
+
+ get allowSuper() {
+ return (this.currentThisScopeFlags() & SCOPE_SUPER) > 0;
+ }
+
+ get allowDirectSuper() {
+ return (this.currentThisScopeFlags() & SCOPE_DIRECT_SUPER) > 0;
+ }
+
+ get inClass() {
+ return (this.currentThisScopeFlags() & SCOPE_CLASS) > 0;
+ }
+
+ get inClassAndNotInNonArrowFunction() {
+ const flags = this.currentThisScopeFlags();
+ return (flags & SCOPE_CLASS) > 0 && (flags & SCOPE_FUNCTION) === 0;
+ }
+
+ get inStaticBlock() {
+ for (let i = this.scopeStack.length - 1;; i--) {
+ const {
+ flags
+ } = this.scopeStack[i];
+
+ if (flags & SCOPE_STATIC_BLOCK) {
+ return true;
+ }
+
+ if (flags & (SCOPE_VAR | SCOPE_CLASS)) {
+ return false;
+ }
+ }
+ }
+
+ get inNonArrowFunction() {
+ return (this.currentThisScopeFlags() & 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 & SCOPE_FUNCTION || !this.inModule && scope.flags & SCOPE_PROGRAM);
+ }
+
+ declareName(name, bindingType, loc) {
+ let scope = this.currentScope();
+
+ if (bindingType & BIND_SCOPE_LEXICAL || bindingType & BIND_SCOPE_FUNCTION) {
+ this.checkRedeclarationInScope(scope, name, bindingType, loc);
+
+ if (bindingType & BIND_SCOPE_FUNCTION) {
+ scope.functions.add(name);
+ } else {
+ scope.lexical.add(name);
+ }
+
+ if (bindingType & BIND_SCOPE_LEXICAL) {
+ this.maybeExportDefined(scope, name);
+ }
+ } else if (bindingType & BIND_SCOPE_VAR) {
+ for (let i = this.scopeStack.length - 1; i >= 0; --i) {
+ scope = this.scopeStack[i];
+ this.checkRedeclarationInScope(scope, name, bindingType, loc);
+ scope.var.add(name);
+ this.maybeExportDefined(scope, name);
+ if (scope.flags & SCOPE_VAR) break;
+ }
+ }
+
+ if (this.inModule && scope.flags & SCOPE_PROGRAM) {
+ this.undefinedExports.delete(name);
+ }
+ }
+
+ maybeExportDefined(scope, name) {
+ if (this.inModule && scope.flags & SCOPE_PROGRAM) {
+ this.undefinedExports.delete(name);
+ }
+ }
+
+ checkRedeclarationInScope(scope, name, bindingType, loc) {
+ if (this.isRedeclaredInScope(scope, name, bindingType)) {
+ this.raise(ErrorMessages.VarRedeclaration, {
+ at: loc
+ }, name);
+ }
+ }
+
+ isRedeclaredInScope(scope, name, bindingType) {
+ if (!(bindingType & BIND_KIND_VALUE)) return false;
+
+ if (bindingType & BIND_SCOPE_LEXICAL) {
+ return scope.lexical.has(name) || scope.functions.has(name) || scope.var.has(name);
+ }
+
+ if (bindingType & BIND_SCOPE_FUNCTION) {
+ return scope.lexical.has(name) || !this.treatFunctionsAsVarInScope(scope) && scope.var.has(name);
+ }
+
+ return scope.lexical.has(name) && !(scope.flags & SCOPE_SIMPLE_CATCH && scope.lexical.values().next().value === name) || !this.treatFunctionsAsVarInScope(scope) && scope.functions.has(name);
+ }
+
+ checkLocalExport(id) {
+ const {
+ name
+ } = id;
+ const topLevelScope = this.scopeStack[0];
+
+ if (!topLevelScope.lexical.has(name) && !topLevelScope.var.has(name) && !topLevelScope.functions.has(name)) {
+ this.undefinedExports.set(name, id.loc.start);
+ }
+ }
+
+ currentScope() {
+ return this.scopeStack[this.scopeStack.length - 1];
+ }
+
+ currentVarScopeFlags() {
+ for (let i = this.scopeStack.length - 1;; i--) {
+ const {
+ flags
+ } = this.scopeStack[i];
+
+ if (flags & SCOPE_VAR) {
+ return flags;
+ }
+ }
+ }
+
+ currentThisScopeFlags() {
+ for (let i = this.scopeStack.length - 1;; i--) {
+ const {
+ flags
+ } = this.scopeStack[i];
+
+ if (flags & (SCOPE_VAR | SCOPE_CLASS) && !(flags & SCOPE_ARROW)) {
+ return flags;
+ }
+ }
+ }
+
+}
+
+class FlowScope extends Scope {
+ constructor(...args) {
+ super(...args);
+ this.declareFunctions = new Set();
+ }
+
+}
+
+class FlowScopeHandler extends ScopeHandler {
+ createScope(flags) {
+ return new FlowScope(flags);
+ }
+
+ declareName(name, bindingType, loc) {
+ const scope = this.currentScope();
+
+ if (bindingType & BIND_FLAGS_FLOW_DECLARE_FN) {
+ this.checkRedeclarationInScope(scope, name, bindingType, loc);
+ this.maybeExportDefined(scope, name);
+ scope.declareFunctions.add(name);
+ return;
+ }
+
+ super.declareName(...arguments);
+ }
+
+ isRedeclaredInScope(scope, name, bindingType) {
+ if (super.isRedeclaredInScope(...arguments)) return true;
+
+ if (bindingType & BIND_FLAGS_FLOW_DECLARE_FN) {
+ return !scope.declareFunctions.has(name) && (scope.lexical.has(name) || scope.functions.has(name));
+ }
+
+ return false;
+ }
+
+ checkLocalExport(id) {
+ if (!this.scopeStack[0].declareFunctions.has(id.name)) {
+ super.checkLocalExport(id);
+ }
+ }
+
+}
+
+const lineBreak = /\r\n?|[\n\u2028\u2029]/;
+const lineBreakG = new RegExp(lineBreak.source, "g");
+function isNewLine(code) {
+ switch (code) {
+ case 10:
+ case 13:
+ case 8232:
+ case 8233:
+ return true;
+
+ default:
+ return false;
+ }
+}
+const skipWhiteSpace = /(?:\s|\/\/.*|\/\*[^]*?\*\/)*/g;
+const skipWhiteSpaceInLine = /(?:[^\S\n\r\u2028\u2029]|\/\/.*|\/\*.*?\*\/)*/y;
+const skipWhiteSpaceToLineBreak = new RegExp("(?=(" + skipWhiteSpaceInLine.source + "))\\1" + /(?=[\n\r\u2028\u2029]|\/\*(?!.*?\*\/)|$)/.source, "y");
+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;
+ }
+}
+
+class State {
+ constructor() {
+ this.strict = void 0;
+ this.curLine = void 0;
+ this.lineStart = void 0;
+ this.startLoc = void 0;
+ this.endLoc = void 0;
+ this.errors = [];
+ this.potentialArrowAt = -1;
+ this.noArrowAt = [];
+ this.noArrowParamsConversionAt = [];
+ this.maybeInArrowParameters = false;
+ this.inType = false;
+ this.noAnonFunctionType = false;
+ this.hasFlowComment = false;
+ this.isAmbientContext = false;
+ this.inAbstractClass = false;
+ this.topicContext = {
+ maxNumOfResolvableTopics: 0,
+ maxTopicIndex: null
+ };
+ this.soloAwait = false;
+ this.inFSharpPipelineDirectBody = false;
+ this.labels = [];
+ this.decoratorStack = [[]];
+ this.comments = [];
+ this.commentStack = [];
+ this.pos = 0;
+ this.type = 135;
+ this.value = null;
+ this.start = 0;
+ this.end = 0;
+ this.lastTokEndLoc = null;
+ this.lastTokStartLoc = null;
+ this.lastTokStart = 0;
+ this.context = [types.brace];
+ this.canStartJSXElement = true;
+ this.containsEsc = false;
+ this.strictErrors = new Map();
+ this.tokensLength = 0;
+ }
+
+ init({
+ strictMode,
+ sourceType,
+ startLine,
+ startColumn
+ }) {
+ this.strict = strictMode === false ? false : strictMode === true ? true : sourceType === "module";
+ this.curLine = startLine;
+ this.lineStart = -startColumn;
+ this.startLoc = this.endLoc = new Position(startLine, startColumn, 0);
+ }
+
+ curPosition() {
+ return new Position(this.curLine, this.pos - this.lineStart, this.pos);
+ }
+
+ 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;
+ }
+
+}
+
+var _isDigit = function isDigit(code) {
+ return code >= 48 && code <= 57;
+};
+const VALID_REGEX_FLAGS = new Set([103, 109, 115, 105, 121, 117, 100, 118]);
+const forbiddenNumericSeparatorSiblings = {
+ decBinOct: [46, 66, 69, 79, 95, 98, 101, 111],
+ hex: [46, 88, 95, 120]
+};
+const allowedNumericSeparatorSiblings = {};
+allowedNumericSeparatorSiblings.bin = [48, 49];
+allowedNumericSeparatorSiblings.oct = [...allowedNumericSeparatorSiblings.bin, 50, 51, 52, 53, 54, 55];
+allowedNumericSeparatorSiblings.dec = [...allowedNumericSeparatorSiblings.oct, 56, 57];
+allowedNumericSeparatorSiblings.hex = [...allowedNumericSeparatorSiblings.dec, 65, 66, 67, 68, 69, 70, 97, 98, 99, 100, 101, 102];
+class Token {
+ constructor(state) {
+ this.type = state.type;
+ this.value = state.value;
+ this.start = state.start;
+ this.end = state.end;
+ this.loc = new SourceLocation(state.startLoc, state.endLoc);
+ }
+
+}
+class Tokenizer extends ParserError {
+ constructor(options, input) {
+ super();
+ this.isLookahead = void 0;
+ this.tokens = [];
+ this.state = new State();
+ this.state.init(options);
+ this.input = input;
+ this.length = input.length;
+ this.isLookahead = false;
+ }
+
+ pushToken(token) {
+ this.tokens.length = this.state.tokensLength;
+ this.tokens.push(token);
+ ++this.state.tokensLength;
+ }
+
+ next() {
+ this.checkKeywordEscapes();
+
+ if (this.options.tokens) {
+ this.pushToken(new Token(this.state));
+ }
+
+ this.state.lastTokStart = this.state.start;
+ this.state.lastTokEndLoc = this.state.endLoc;
+ this.state.lastTokStartLoc = this.state.startLoc;
+ this.nextToken();
+ }
+
+ eat(type) {
+ if (this.match(type)) {
+ this.next();
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ match(type) {
+ return this.state.type === type;
+ }
+
+ createLookaheadState(state) {
+ return {
+ pos: state.pos,
+ value: null,
+ type: state.type,
+ start: state.start,
+ end: state.end,
+ context: [this.curContext()],
+ inType: state.inType,
+ startLoc: state.startLoc,
+ lastTokEndLoc: state.lastTokEndLoc,
+ curLine: state.curLine,
+ lineStart: state.lineStart,
+ curPosition: state.curPosition
+ };
+ }
+
+ lookahead() {
+ const old = this.state;
+ this.state = this.createLookaheadState(old);
+ this.isLookahead = true;
+ this.nextToken();
+ this.isLookahead = false;
+ const curr = this.state;
+ this.state = old;
+ return curr;
+ }
+
+ nextTokenStart() {
+ return this.nextTokenStartSince(this.state.pos);
+ }
+
+ nextTokenStartSince(pos) {
+ skipWhiteSpace.lastIndex = pos;
+ return skipWhiteSpace.test(this.input) ? skipWhiteSpace.lastIndex : pos;
+ }
+
+ lookaheadCharCode() {
+ return this.input.charCodeAt(this.nextTokenStart());
+ }
+
+ codePointAtPos(pos) {
+ let cp = this.input.charCodeAt(pos);
+
+ if ((cp & 0xfc00) === 0xd800 && ++pos < this.input.length) {
+ const trail = this.input.charCodeAt(pos);
+
+ if ((trail & 0xfc00) === 0xdc00) {
+ cp = 0x10000 + ((cp & 0x3ff) << 10) + (trail & 0x3ff);
+ }
+ }
+
+ return cp;
+ }
+
+ setStrict(strict) {
+ this.state.strict = strict;
+
+ if (strict) {
+ this.state.strictErrors.forEach(({
+ message,
+ loc
+ }) => this.raise(message, {
+ at: loc
+ }));
+ this.state.strictErrors.clear();
+ }
+ }
+
+ curContext() {
+ return this.state.context[this.state.context.length - 1];
+ }
+
+ nextToken() {
+ this.skipSpace();
+ this.state.start = this.state.pos;
+ if (!this.isLookahead) this.state.startLoc = this.state.curPosition();
+
+ if (this.state.pos >= this.length) {
+ this.finishToken(135);
+ return;
+ }
+
+ this.getTokenFromCode(this.codePointAtPos(this.state.pos));
+ }
+
+ skipBlockComment() {
+ let startLoc;
+ if (!this.isLookahead) startLoc = this.state.curPosition();
+ const start = this.state.pos;
+ const end = this.input.indexOf("*/", start + 2);
+
+ if (end === -1) {
+ throw this.raise(ErrorMessages.UnterminatedComment, {
+ at: this.state.curPosition()
+ });
+ }
+
+ this.state.pos = end + 2;
+ lineBreakG.lastIndex = start + 2;
+
+ while (lineBreakG.test(this.input) && lineBreakG.lastIndex <= end) {
+ ++this.state.curLine;
+ this.state.lineStart = lineBreakG.lastIndex;
+ }
+
+ if (this.isLookahead) return;
+ const comment = {
+ type: "CommentBlock",
+ value: this.input.slice(start + 2, end),
+ start,
+ end: end + 2,
+ loc: new SourceLocation(startLoc, this.state.curPosition())
+ };
+ if (this.options.tokens) this.pushToken(comment);
+ return comment;
+ }
+
+ skipLineComment(startSkip) {
+ const start = this.state.pos;
+ let startLoc;
+ if (!this.isLookahead) startLoc = this.state.curPosition();
+ let ch = this.input.charCodeAt(this.state.pos += startSkip);
+
+ if (this.state.pos < this.length) {
+ while (!isNewLine(ch) && ++this.state.pos < this.length) {
+ ch = this.input.charCodeAt(this.state.pos);
+ }
+ }
+
+ if (this.isLookahead) return;
+ const end = this.state.pos;
+ const value = this.input.slice(start + startSkip, end);
+ const comment = {
+ type: "CommentLine",
+ value,
+ start,
+ end,
+ loc: new SourceLocation(startLoc, this.state.curPosition())
+ };
+ if (this.options.tokens) this.pushToken(comment);
+ return comment;
+ }
+
+ skipSpace() {
+ const spaceStart = this.state.pos;
+ const comments = [];
+
+ loop: while (this.state.pos < this.length) {
+ const ch = this.input.charCodeAt(this.state.pos);
+
+ switch (ch) {
+ case 32:
+ case 160:
+ case 9:
+ ++this.state.pos;
+ break;
+
+ case 13:
+ if (this.input.charCodeAt(this.state.pos + 1) === 10) {
+ ++this.state.pos;
+ }
+
+ case 10:
+ case 8232:
+ case 8233:
+ ++this.state.pos;
+ ++this.state.curLine;
+ this.state.lineStart = this.state.pos;
+ break;
+
+ case 47:
+ switch (this.input.charCodeAt(this.state.pos + 1)) {
+ case 42:
+ {
+ const comment = this.skipBlockComment();
+
+ if (comment !== undefined) {
+ this.addComment(comment);
+ if (this.options.attachComment) comments.push(comment);
+ }
+
+ break;
+ }
+
+ case 47:
+ {
+ const comment = this.skipLineComment(2);
+
+ if (comment !== undefined) {
+ this.addComment(comment);
+ if (this.options.attachComment) comments.push(comment);
+ }
+
+ break;
+ }
+
+ default:
+ break loop;
+ }
+
+ break;
+
+ default:
+ if (isWhitespace(ch)) {
+ ++this.state.pos;
+ } else if (ch === 45 && !this.inModule) {
+ const pos = this.state.pos;
+
+ if (this.input.charCodeAt(pos + 1) === 45 && this.input.charCodeAt(pos + 2) === 62 && (spaceStart === 0 || this.state.lineStart > spaceStart)) {
+ const comment = this.skipLineComment(3);
+
+ if (comment !== undefined) {
+ this.addComment(comment);
+ if (this.options.attachComment) comments.push(comment);
+ }
+ } else {
+ break loop;
+ }
+ } else if (ch === 60 && !this.inModule) {
+ const pos = this.state.pos;
+
+ if (this.input.charCodeAt(pos + 1) === 33 && this.input.charCodeAt(pos + 2) === 45 && this.input.charCodeAt(pos + 3) === 45) {
+ const comment = this.skipLineComment(4);
+
+ if (comment !== undefined) {
+ this.addComment(comment);
+ if (this.options.attachComment) comments.push(comment);
+ }
+ } else {
+ break loop;
+ }
+ } else {
+ break loop;
+ }
+
+ }
+ }
+
+ if (comments.length > 0) {
+ const end = this.state.pos;
+ const CommentWhitespace = {
+ start: spaceStart,
+ end,
+ comments,
+ leadingNode: null,
+ trailingNode: null,
+ containingNode: null
+ };
+ this.state.commentStack.push(CommentWhitespace);
+ }
+ }
+
+ finishToken(type, val) {
+ this.state.end = this.state.pos;
+ this.state.endLoc = this.state.curPosition();
+ const prevType = this.state.type;
+ this.state.type = type;
+ this.state.value = val;
+
+ if (!this.isLookahead) {
+ this.updateContext(prevType);
+ }
+ }
+
+ replaceToken(type) {
+ this.state.type = type;
+ this.updateContext();
+ }
+
+ readToken_numberSign() {
+ if (this.state.pos === 0 && this.readToken_interpreter()) {
+ return;
+ }
+
+ const nextPos = this.state.pos + 1;
+ const next = this.codePointAtPos(nextPos);
+
+ if (next >= 48 && next <= 57) {
+ throw this.raise(ErrorMessages.UnexpectedDigitAfterHash, {
+ at: this.state.curPosition()
+ });
+ }
+
+ if (next === 123 || next === 91 && this.hasPlugin("recordAndTuple")) {
+ this.expectPlugin("recordAndTuple");
+
+ if (this.getPluginOption("recordAndTuple", "syntaxType") !== "hash") {
+ throw this.raise(next === 123 ? ErrorMessages.RecordExpressionHashIncorrectStartSyntaxType : ErrorMessages.TupleExpressionHashIncorrectStartSyntaxType, {
+ at: this.state.curPosition()
+ });
+ }
+
+ this.state.pos += 2;
+
+ if (next === 123) {
+ this.finishToken(7);
+ } else {
+ this.finishToken(1);
+ }
+ } else if (isIdentifierStart(next)) {
+ ++this.state.pos;
+ this.finishToken(134, this.readWord1(next));
+ } else if (next === 92) {
+ ++this.state.pos;
+ this.finishToken(134, this.readWord1());
+ } else {
+ this.finishOp(27, 1);
+ }
+ }
+
+ readToken_dot() {
+ const next = this.input.charCodeAt(this.state.pos + 1);
+
+ if (next >= 48 && next <= 57) {
+ this.readNumber(true);
+ return;
+ }
+
+ if (next === 46 && this.input.charCodeAt(this.state.pos + 2) === 46) {
+ this.state.pos += 3;
+ this.finishToken(21);
+ } else {
+ ++this.state.pos;
+ this.finishToken(16);
+ }
+ }
+
+ readToken_slash() {
+ const next = this.input.charCodeAt(this.state.pos + 1);
+
+ if (next === 61) {
+ this.finishOp(31, 2);
+ } else {
+ this.finishOp(56, 1);
+ }
+ }
+
+ readToken_interpreter() {
+ if (this.state.pos !== 0 || this.length < 2) return false;
+ let ch = this.input.charCodeAt(this.state.pos + 1);
+ if (ch !== 33) return false;
+ const start = this.state.pos;
+ this.state.pos += 1;
+
+ while (!isNewLine(ch) && ++this.state.pos < this.length) {
+ ch = this.input.charCodeAt(this.state.pos);
+ }
+
+ const value = this.input.slice(start + 2, this.state.pos);
+ this.finishToken(28, value);
+ return true;
+ }
+
+ readToken_mult_modulo(code) {
+ let type = code === 42 ? 55 : 54;
+ let width = 1;
+ let next = this.input.charCodeAt(this.state.pos + 1);
+
+ if (code === 42 && next === 42) {
+ width++;
+ next = this.input.charCodeAt(this.state.pos + 2);
+ type = 57;
+ }
+
+ if (next === 61 && !this.state.inType) {
+ width++;
+ type = code === 37 ? 33 : 30;
+ }
+
+ this.finishOp(type, width);
+ }
+
+ readToken_pipe_amp(code) {
+ const next = this.input.charCodeAt(this.state.pos + 1);
+
+ if (next === code) {
+ if (this.input.charCodeAt(this.state.pos + 2) === 61) {
+ this.finishOp(30, 3);
+ } else {
+ this.finishOp(code === 124 ? 41 : 42, 2);
+ }
+
+ return;
+ }
+
+ if (code === 124) {
+ if (next === 62) {
+ this.finishOp(39, 2);
+ return;
+ }
+
+ if (this.hasPlugin("recordAndTuple") && next === 125) {
+ if (this.getPluginOption("recordAndTuple", "syntaxType") !== "bar") {
+ throw this.raise(ErrorMessages.RecordExpressionBarIncorrectEndSyntaxType, {
+ at: this.state.curPosition()
+ });
+ }
+
+ this.state.pos += 2;
+ this.finishToken(9);
+ return;
+ }
+
+ if (this.hasPlugin("recordAndTuple") && next === 93) {
+ if (this.getPluginOption("recordAndTuple", "syntaxType") !== "bar") {
+ throw this.raise(ErrorMessages.TupleExpressionBarIncorrectEndSyntaxType, {
+ at: this.state.curPosition()
+ });
+ }
+
+ this.state.pos += 2;
+ this.finishToken(4);
+ return;
+ }
+ }
+
+ if (next === 61) {
+ this.finishOp(30, 2);
+ return;
+ }
+
+ this.finishOp(code === 124 ? 43 : 45, 1);
+ }
+
+ readToken_caret() {
+ const next = this.input.charCodeAt(this.state.pos + 1);
+
+ if (next === 61 && !this.state.inType) {
+ this.finishOp(32, 2);
+ } else if (next === 94 && this.hasPlugin(["pipelineOperator", {
+ proposal: "hack",
+ topicToken: "^^"
+ }])) {
+ this.finishOp(37, 2);
+ const lookaheadCh = this.input.codePointAt(this.state.pos);
+
+ if (lookaheadCh === 94) {
+ throw this.unexpected();
+ }
+ } else {
+ this.finishOp(44, 1);
+ }
+ }
+
+ readToken_atSign() {
+ const next = this.input.charCodeAt(this.state.pos + 1);
+
+ if (next === 64 && this.hasPlugin(["pipelineOperator", {
+ proposal: "hack",
+ topicToken: "@@"
+ }])) {
+ this.finishOp(38, 2);
+ } else {
+ this.finishOp(26, 1);
+ }
+ }
+
+ readToken_plus_min(code) {
+ const next = this.input.charCodeAt(this.state.pos + 1);
+
+ if (next === code) {
+ this.finishOp(34, 2);
+ return;
+ }
+
+ if (next === 61) {
+ this.finishOp(30, 2);
+ } else {
+ this.finishOp(53, 1);
+ }
+ }
+
+ readToken_lt() {
+ const {
+ pos
+ } = this.state;
+ const next = this.input.charCodeAt(pos + 1);
+
+ if (next === 60) {
+ if (this.input.charCodeAt(pos + 2) === 61) {
+ this.finishOp(30, 3);
+ return;
+ }
+
+ this.finishOp(51, 2);
+ return;
+ }
+
+ if (next === 61) {
+ this.finishOp(49, 2);
+ return;
+ }
+
+ this.finishOp(47, 1);
+ }
+
+ readToken_gt() {
+ const {
+ pos
+ } = this.state;
+ const next = this.input.charCodeAt(pos + 1);
+
+ if (next === 62) {
+ const size = this.input.charCodeAt(pos + 2) === 62 ? 3 : 2;
+
+ if (this.input.charCodeAt(pos + size) === 61) {
+ this.finishOp(30, size + 1);
+ return;
+ }
+
+ this.finishOp(52, size);
+ return;
+ }
+
+ if (next === 61) {
+ this.finishOp(49, 2);
+ return;
+ }
+
+ this.finishOp(48, 1);
+ }
+
+ readToken_eq_excl(code) {
+ const next = this.input.charCodeAt(this.state.pos + 1);
+
+ if (next === 61) {
+ this.finishOp(46, this.input.charCodeAt(this.state.pos + 2) === 61 ? 3 : 2);
+ return;
+ }
+
+ if (code === 61 && next === 62) {
+ this.state.pos += 2;
+ this.finishToken(19);
+ return;
+ }
+
+ this.finishOp(code === 61 ? 29 : 35, 1);
+ }
+
+ readToken_question() {
+ const next = this.input.charCodeAt(this.state.pos + 1);
+ const next2 = this.input.charCodeAt(this.state.pos + 2);
+
+ if (next === 63) {
+ if (next2 === 61) {
+ this.finishOp(30, 3);
+ } else {
+ this.finishOp(40, 2);
+ }
+ } else if (next === 46 && !(next2 >= 48 && next2 <= 57)) {
+ this.state.pos += 2;
+ this.finishToken(18);
+ } else {
+ ++this.state.pos;
+ this.finishToken(17);
+ }
+ }
+
+ getTokenFromCode(code) {
+ switch (code) {
+ case 46:
+ this.readToken_dot();
+ return;
+
+ case 40:
+ ++this.state.pos;
+ this.finishToken(10);
+ return;
+
+ case 41:
+ ++this.state.pos;
+ this.finishToken(11);
+ return;
+
+ case 59:
+ ++this.state.pos;
+ this.finishToken(13);
+ return;
+
+ case 44:
+ ++this.state.pos;
+ this.finishToken(12);
+ return;
+
+ case 91:
+ if (this.hasPlugin("recordAndTuple") && this.input.charCodeAt(this.state.pos + 1) === 124) {
+ if (this.getPluginOption("recordAndTuple", "syntaxType") !== "bar") {
+ throw this.raise(ErrorMessages.TupleExpressionBarIncorrectStartSyntaxType, {
+ at: this.state.curPosition()
+ });
+ }
+
+ this.state.pos += 2;
+ this.finishToken(2);
+ } else {
+ ++this.state.pos;
+ this.finishToken(0);
+ }
+
+ return;
+
+ case 93:
+ ++this.state.pos;
+ this.finishToken(3);
+ return;
+
+ case 123:
+ if (this.hasPlugin("recordAndTuple") && this.input.charCodeAt(this.state.pos + 1) === 124) {
+ if (this.getPluginOption("recordAndTuple", "syntaxType") !== "bar") {
+ throw this.raise(ErrorMessages.RecordExpressionBarIncorrectStartSyntaxType, {
+ at: this.state.curPosition()
+ });
+ }
+
+ this.state.pos += 2;
+ this.finishToken(6);
+ } else {
+ ++this.state.pos;
+ this.finishToken(5);
+ }
+
+ return;
+
+ case 125:
+ ++this.state.pos;
+ this.finishToken(8);
+ return;
+
+ case 58:
+ if (this.hasPlugin("functionBind") && this.input.charCodeAt(this.state.pos + 1) === 58) {
+ this.finishOp(15, 2);
+ } else {
+ ++this.state.pos;
+ this.finishToken(14);
+ }
+
+ return;
+
+ case 63:
+ this.readToken_question();
+ return;
+
+ case 96:
+ this.readTemplateToken();
+ return;
+
+ case 48:
+ {
+ const next = this.input.charCodeAt(this.state.pos + 1);
+
+ if (next === 120 || next === 88) {
+ this.readRadixNumber(16);
+ return;
+ }
+
+ if (next === 111 || next === 79) {
+ this.readRadixNumber(8);
+ return;
+ }
+
+ if (next === 98 || next === 66) {
+ this.readRadixNumber(2);
+ return;
+ }
+ }
+
+ case 49:
+ case 50:
+ case 51:
+ case 52:
+ case 53:
+ case 54:
+ case 55:
+ case 56:
+ case 57:
+ this.readNumber(false);
+ return;
+
+ case 34:
+ case 39:
+ this.readString(code);
+ return;
+
+ case 47:
+ this.readToken_slash();
+ return;
+
+ case 37:
+ case 42:
+ this.readToken_mult_modulo(code);
+ return;
+
+ case 124:
+ case 38:
+ this.readToken_pipe_amp(code);
+ return;
+
+ case 94:
+ this.readToken_caret();
+ return;
+
+ case 43:
+ case 45:
+ this.readToken_plus_min(code);
+ return;
+
+ case 60:
+ this.readToken_lt();
+ return;
+
+ case 62:
+ this.readToken_gt();
+ return;
+
+ case 61:
+ case 33:
+ this.readToken_eq_excl(code);
+ return;
+
+ case 126:
+ this.finishOp(36, 1);
+ return;
+
+ case 64:
+ this.readToken_atSign();
+ return;
+
+ case 35:
+ this.readToken_numberSign();
+ return;
+
+ case 92:
+ this.readWord();
+ return;
+
+ default:
+ if (isIdentifierStart(code)) {
+ this.readWord(code);
+ return;
+ }
+
+ }
+
+ throw this.raise(ErrorMessages.InvalidOrUnexpectedToken, {
+ at: this.state.curPosition()
+ }, String.fromCodePoint(code));
+ }
+
+ finishOp(type, size) {
+ const str = this.input.slice(this.state.pos, this.state.pos + size);
+ this.state.pos += size;
+ this.finishToken(type, str);
+ }
+
+ readRegexp() {
+ const startLoc = this.state.startLoc;
+ const start = this.state.start + 1;
+ let escaped, inClass;
+ let {
+ pos
+ } = this.state;
+
+ for (;; ++pos) {
+ if (pos >= this.length) {
+ throw this.raise(ErrorMessages.UnterminatedRegExp, {
+ at: createPositionWithColumnOffset(startLoc, 1)
+ });
+ }
+
+ const ch = this.input.charCodeAt(pos);
+
+ if (isNewLine(ch)) {
+ throw this.raise(ErrorMessages.UnterminatedRegExp, {
+ at: createPositionWithColumnOffset(startLoc, 1)
+ });
+ }
+
+ if (escaped) {
+ escaped = false;
+ } else {
+ if (ch === 91) {
+ inClass = true;
+ } else if (ch === 93 && inClass) {
+ inClass = false;
+ } else if (ch === 47 && !inClass) {
+ break;
+ }
+
+ escaped = ch === 92;
+ }
+ }
+
+ const content = this.input.slice(start, pos);
+ ++pos;
+ let mods = "";
+
+ const nextPos = () => createPositionWithColumnOffset(startLoc, pos + 2 - start);
+
+ while (pos < this.length) {
+ const cp = this.codePointAtPos(pos);
+ const char = String.fromCharCode(cp);
+
+ if (VALID_REGEX_FLAGS.has(cp)) {
+ if (cp === 118) {
+ this.expectPlugin("regexpUnicodeSets", nextPos());
+
+ if (mods.includes("u")) {
+ this.raise(ErrorMessages.IncompatibleRegExpUVFlags, {
+ at: nextPos()
+ });
+ }
+ } else if (cp === 117) {
+ if (mods.includes("v")) {
+ this.raise(ErrorMessages.IncompatibleRegExpUVFlags, {
+ at: nextPos()
+ });
+ }
+ }
+
+ if (mods.includes(char)) {
+ this.raise(ErrorMessages.DuplicateRegExpFlags, {
+ at: nextPos()
+ });
+ }
+ } else if (isIdentifierChar(cp) || cp === 92) {
+ this.raise(ErrorMessages.MalformedRegExpFlags, {
+ at: nextPos()
+ });
+ } else {
+ break;
+ }
+
+ ++pos;
+ mods += char;
+ }
+
+ this.state.pos = pos;
+ this.finishToken(133, {
+ pattern: content,
+ flags: mods
+ });
+ }
+
+ readInt(radix, len, forceLen, allowNumSeparator = true) {
+ const start = this.state.pos;
+ const forbiddenSiblings = radix === 16 ? forbiddenNumericSeparatorSiblings.hex : forbiddenNumericSeparatorSiblings.decBinOct;
+ const allowedSiblings = radix === 16 ? allowedNumericSeparatorSiblings.hex : radix === 10 ? allowedNumericSeparatorSiblings.dec : radix === 8 ? allowedNumericSeparatorSiblings.oct : allowedNumericSeparatorSiblings.bin;
+ let invalid = false;
+ let total = 0;
+
+ for (let i = 0, e = len == null ? Infinity : len; i < e; ++i) {
+ const code = this.input.charCodeAt(this.state.pos);
+ let val;
+
+ if (code === 95) {
+ const prev = this.input.charCodeAt(this.state.pos - 1);
+ const next = this.input.charCodeAt(this.state.pos + 1);
+
+ if (allowedSiblings.indexOf(next) === -1) {
+ this.raise(ErrorMessages.UnexpectedNumericSeparator, {
+ at: this.state.curPosition()
+ });
+ } else if (forbiddenSiblings.indexOf(prev) > -1 || forbiddenSiblings.indexOf(next) > -1 || Number.isNaN(next)) {
+ this.raise(ErrorMessages.UnexpectedNumericSeparator, {
+ at: this.state.curPosition()
+ });
+ }
+
+ if (!allowNumSeparator) {
+ this.raise(ErrorMessages.NumericSeparatorInEscapeSequence, {
+ at: this.state.curPosition()
+ });
+ }
+
+ ++this.state.pos;
+ continue;
+ }
+
+ if (code >= 97) {
+ val = code - 97 + 10;
+ } else if (code >= 65) {
+ val = code - 65 + 10;
+ } else if (_isDigit(code)) {
+ val = code - 48;
+ } else {
+ val = Infinity;
+ }
+
+ if (val >= radix) {
+ if (this.options.errorRecovery && val <= 9) {
+ val = 0;
+ this.raise(ErrorMessages.InvalidDigit, {
+ at: this.state.curPosition()
+ }, radix);
+ } else if (forceLen) {
+ val = 0;
+ invalid = true;
+ } else {
+ break;
+ }
+ }
+
+ ++this.state.pos;
+ total = total * radix + val;
+ }
+
+ if (this.state.pos === start || len != null && this.state.pos - start !== len || invalid) {
+ return null;
+ }
+
+ return total;
+ }
+
+ readRadixNumber(radix) {
+ const startLoc = this.state.curPosition();
+ let isBigInt = false;
+ this.state.pos += 2;
+ const val = this.readInt(radix);
+
+ if (val == null) {
+ this.raise(ErrorMessages.InvalidDigit, {
+ at: createPositionWithColumnOffset(startLoc, 2)
+ }, radix);
+ }
+
+ const next = this.input.charCodeAt(this.state.pos);
+
+ if (next === 110) {
+ ++this.state.pos;
+ isBigInt = true;
+ } else if (next === 109) {
+ throw this.raise(ErrorMessages.InvalidDecimal, {
+ at: startLoc
+ });
+ }
+
+ if (isIdentifierStart(this.codePointAtPos(this.state.pos))) {
+ throw this.raise(ErrorMessages.NumberIdentifier, {
+ at: this.state.curPosition()
+ });
+ }
+
+ if (isBigInt) {
+ const str = this.input.slice(startLoc.index, this.state.pos).replace(/[_n]/g, "");
+ this.finishToken(131, str);
+ return;
+ }
+
+ this.finishToken(130, val);
+ }
+
+ readNumber(startsWithDot) {
+ const start = this.state.pos;
+ const startLoc = this.state.curPosition();
+ let isFloat = false;
+ let isBigInt = false;
+ let isDecimal = false;
+ let hasExponent = false;
+ let isOctal = false;
+
+ if (!startsWithDot && this.readInt(10) === null) {
+ this.raise(ErrorMessages.InvalidNumber, {
+ at: this.state.curPosition()
+ });
+ }
+
+ const hasLeadingZero = this.state.pos - start >= 2 && this.input.charCodeAt(start) === 48;
+
+ if (hasLeadingZero) {
+ const integer = this.input.slice(start, this.state.pos);
+ this.recordStrictModeErrors(ErrorMessages.StrictOctalLiteral, startLoc);
+
+ if (!this.state.strict) {
+ const underscorePos = integer.indexOf("_");
+
+ if (underscorePos > 0) {
+ this.raise(ErrorMessages.ZeroDigitNumericSeparator, {
+ at: createPositionWithColumnOffset(startLoc, underscorePos)
+ });
+ }
+ }
+
+ isOctal = hasLeadingZero && !/[89]/.test(integer);
+ }
+
+ let next = this.input.charCodeAt(this.state.pos);
+
+ if (next === 46 && !isOctal) {
+ ++this.state.pos;
+ this.readInt(10);
+ isFloat = true;
+ next = this.input.charCodeAt(this.state.pos);
+ }
+
+ if ((next === 69 || next === 101) && !isOctal) {
+ next = this.input.charCodeAt(++this.state.pos);
+
+ if (next === 43 || next === 45) {
+ ++this.state.pos;
+ }
+
+ if (this.readInt(10) === null) {
+ this.raise(ErrorMessages.InvalidOrMissingExponent, {
+ at: startLoc
+ });
+ }
+
+ isFloat = true;
+ hasExponent = true;
+ next = this.input.charCodeAt(this.state.pos);
+ }
+
+ if (next === 110) {
+ if (isFloat || hasLeadingZero) {
+ this.raise(ErrorMessages.InvalidBigIntLiteral, {
+ at: startLoc
+ });
+ }
+
+ ++this.state.pos;
+ isBigInt = true;
+ }
+
+ if (next === 109) {
+ this.expectPlugin("decimal", this.state.curPosition());
+
+ if (hasExponent || hasLeadingZero) {
+ this.raise(ErrorMessages.InvalidDecimal, {
+ at: startLoc
+ });
+ }
+
+ ++this.state.pos;
+ isDecimal = true;
+ }
+
+ if (isIdentifierStart(this.codePointAtPos(this.state.pos))) {
+ throw this.raise(ErrorMessages.NumberIdentifier, {
+ at: this.state.curPosition()
+ });
+ }
+
+ const str = this.input.slice(start, this.state.pos).replace(/[_mn]/g, "");
+
+ if (isBigInt) {
+ this.finishToken(131, str);
+ return;
+ }
+
+ if (isDecimal) {
+ this.finishToken(132, str);
+ return;
+ }
+
+ const val = isOctal ? parseInt(str, 8) : parseFloat(str);
+ this.finishToken(130, val);
+ }
+
+ readCodePoint(throwOnInvalid) {
+ const ch = this.input.charCodeAt(this.state.pos);
+ let code;
+
+ if (ch === 123) {
+ ++this.state.pos;
+ code = this.readHexChar(this.input.indexOf("}", this.state.pos) - this.state.pos, true, throwOnInvalid);
+ ++this.state.pos;
+
+ if (code !== null && code > 0x10ffff) {
+ if (throwOnInvalid) {
+ this.raise(ErrorMessages.InvalidCodePoint, {
+ at: this.state.curPosition()
+ });
+ } else {
+ return null;
+ }
+ }
+ } else {
+ code = this.readHexChar(4, false, throwOnInvalid);
+ }
+
+ return code;
+ }
+
+ readString(quote) {
+ let out = "",
+ chunkStart = ++this.state.pos;
+
+ for (;;) {
+ if (this.state.pos >= this.length) {
+ throw this.raise(ErrorMessages.UnterminatedString, {
+ at: this.state.startLoc
+ });
+ }
+
+ const ch = this.input.charCodeAt(this.state.pos);
+ if (ch === quote) break;
+
+ if (ch === 92) {
+ out += this.input.slice(chunkStart, this.state.pos);
+ out += this.readEscapedChar(false);
+ chunkStart = this.state.pos;
+ } else if (ch === 8232 || ch === 8233) {
+ ++this.state.pos;
+ ++this.state.curLine;
+ this.state.lineStart = this.state.pos;
+ } else if (isNewLine(ch)) {
+ throw this.raise(ErrorMessages.UnterminatedString, {
+ at: this.state.startLoc
+ });
+ } else {
+ ++this.state.pos;
+ }
+ }
+
+ out += this.input.slice(chunkStart, this.state.pos++);
+ this.finishToken(129, out);
+ }
+
+ readTemplateContinuation() {
+ if (!this.match(8)) {
+ this.unexpected(null, 8);
+ }
+
+ this.state.pos--;
+ this.readTemplateToken();
+ }
+
+ readTemplateToken() {
+ let out = "",
+ chunkStart = this.state.pos,
+ containsInvalid = false;
+ ++this.state.pos;
+
+ for (;;) {
+ if (this.state.pos >= this.length) {
+ throw this.raise(ErrorMessages.UnterminatedTemplate, {
+ at: createPositionWithColumnOffset(this.state.startLoc, 1)
+ });
+ }
+
+ const ch = this.input.charCodeAt(this.state.pos);
+
+ if (ch === 96) {
+ ++this.state.pos;
+ out += this.input.slice(chunkStart, this.state.pos);
+ this.finishToken(24, containsInvalid ? null : out);
+ return;
+ }
+
+ if (ch === 36 && this.input.charCodeAt(this.state.pos + 1) === 123) {
+ this.state.pos += 2;
+ out += this.input.slice(chunkStart, this.state.pos);
+ this.finishToken(25, containsInvalid ? null : out);
+ return;
+ }
+
+ if (ch === 92) {
+ out += this.input.slice(chunkStart, this.state.pos);
+ const escaped = this.readEscapedChar(true);
+
+ if (escaped === null) {
+ containsInvalid = true;
+ } else {
+ out += escaped;
+ }
+
+ chunkStart = this.state.pos;
+ } else if (isNewLine(ch)) {
+ out += this.input.slice(chunkStart, this.state.pos);
+ ++this.state.pos;
+
+ switch (ch) {
+ case 13:
+ if (this.input.charCodeAt(this.state.pos) === 10) {
+ ++this.state.pos;
+ }
+
+ case 10:
+ out += "\n";
+ break;
+
+ default:
+ out += String.fromCharCode(ch);
+ break;
+ }
+
+ ++this.state.curLine;
+ this.state.lineStart = this.state.pos;
+ chunkStart = this.state.pos;
+ } else {
+ ++this.state.pos;
+ }
+ }
+ }
+
+ recordStrictModeErrors(message, loc) {
+ if (this.state.strict && !this.state.strictErrors.has(loc.index)) {
+ this.raise(message, {
+ at: loc
+ });
+ } else {
+ this.state.strictErrors.set(loc.index, {
+ loc,
+ message
+ });
+ }
+ }
+
+ readEscapedChar(inTemplate) {
+ const throwOnInvalid = !inTemplate;
+ const ch = this.input.charCodeAt(++this.state.pos);
+ ++this.state.pos;
+
+ switch (ch) {
+ case 110:
+ return "\n";
+
+ case 114:
+ return "\r";
+
+ case 120:
+ {
+ const code = this.readHexChar(2, false, throwOnInvalid);
+ return code === null ? null : String.fromCharCode(code);
+ }
+
+ case 117:
+ {
+ const code = this.readCodePoint(throwOnInvalid);
+ return code === null ? null : String.fromCodePoint(code);
+ }
+
+ case 116:
+ return "\t";
+
+ case 98:
+ return "\b";
+
+ case 118:
+ return "\u000b";
+
+ case 102:
+ return "\f";
+
+ case 13:
+ if (this.input.charCodeAt(this.state.pos) === 10) {
+ ++this.state.pos;
+ }
+
+ case 10:
+ this.state.lineStart = this.state.pos;
+ ++this.state.curLine;
+
+ case 8232:
+ case 8233:
+ return "";
+
+ case 56:
+ case 57:
+ if (inTemplate) {
+ return null;
+ } else {
+ this.recordStrictModeErrors(ErrorMessages.StrictNumericEscape, createPositionWithColumnOffset(this.state.curPosition(), -1));
+ }
+
+ default:
+ if (ch >= 48 && ch <= 55) {
+ const codePos = createPositionWithColumnOffset(this.state.curPosition(), -1);
+ const match = this.input.substr(this.state.pos - 1, 3).match(/^[0-7]+/);
+ let octalStr = match[0];
+ let octal = parseInt(octalStr, 8);
+
+ if (octal > 255) {
+ octalStr = octalStr.slice(0, -1);
+ octal = parseInt(octalStr, 8);
+ }
+
+ this.state.pos += octalStr.length - 1;
+ const next = this.input.charCodeAt(this.state.pos);
+
+ if (octalStr !== "0" || next === 56 || next === 57) {
+ if (inTemplate) {
+ return null;
+ } else {
+ this.recordStrictModeErrors(ErrorMessages.StrictNumericEscape, codePos);
+ }
+ }
+
+ return String.fromCharCode(octal);
+ }
+
+ return String.fromCharCode(ch);
+ }
+ }
+
+ readHexChar(len, forceLen, throwOnInvalid) {
+ const codeLoc = this.state.curPosition();
+ const n = this.readInt(16, len, forceLen, false);
+
+ if (n === null) {
+ if (throwOnInvalid) {
+ this.raise(ErrorMessages.InvalidEscapeSequence, {
+ at: codeLoc
+ });
+ } else {
+ this.state.pos = codeLoc.index - 1;
+ }
+ }
+
+ return n;
+ }
+
+ readWord1(firstCode) {
+ this.state.containsEsc = false;
+ let word = "";
+ const start = this.state.pos;
+ let chunkStart = this.state.pos;
+
+ if (firstCode !== undefined) {
+ this.state.pos += firstCode <= 0xffff ? 1 : 2;
+ }
+
+ while (this.state.pos < this.length) {
+ const ch = this.codePointAtPos(this.state.pos);
+
+ if (isIdentifierChar(ch)) {
+ this.state.pos += ch <= 0xffff ? 1 : 2;
+ } else if (ch === 92) {
+ this.state.containsEsc = true;
+ word += this.input.slice(chunkStart, this.state.pos);
+ const escStart = this.state.curPosition();
+ const identifierCheck = this.state.pos === start ? isIdentifierStart : isIdentifierChar;
+
+ if (this.input.charCodeAt(++this.state.pos) !== 117) {
+ this.raise(ErrorMessages.MissingUnicodeEscape, {
+ at: this.state.curPosition()
+ });
+ chunkStart = this.state.pos - 1;
+ continue;
+ }
+
+ ++this.state.pos;
+ const esc = this.readCodePoint(true);
+
+ if (esc !== null) {
+ if (!identifierCheck(esc)) {
+ this.raise(ErrorMessages.EscapedCharNotAnIdentifier, {
+ at: escStart
+ });
+ }
+
+ word += String.fromCodePoint(esc);
+ }
+
+ chunkStart = this.state.pos;
+ } else {
+ break;
+ }
+ }
+
+ return word + this.input.slice(chunkStart, this.state.pos);
+ }
+
+ readWord(firstCode) {
+ const word = this.readWord1(firstCode);
+ const type = keywords$1.get(word);
+
+ if (type !== undefined) {
+ this.finishToken(type, tokenLabelName(type));
+ } else {
+ this.finishToken(128, word);
+ }
+ }
+
+ checkKeywordEscapes() {
+ const {
+ type
+ } = this.state;
+
+ if (tokenIsKeyword(type) && this.state.containsEsc) {
+ this.raise(ErrorMessages.InvalidEscapedReservedWord, {
+ at: this.state.startLoc
+ }, tokenLabelName(type));
+ }
+ }
+
+ updateContext(prevType) {}
+
+}
+
+class ClassScope {
+ constructor() {
+ this.privateNames = new Set();
+ this.loneAccessors = new Map();
+ this.undefinedPrivateNames = new Map();
+ }
+
+}
+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 (const [name, loc] of Array.from(oldClassScope.undefinedPrivateNames)) {
+ if (current) {
+ if (!current.undefinedPrivateNames.has(name)) {
+ current.undefinedPrivateNames.set(name, loc);
+ }
+ } else {
+ this.raise(ErrorMessages.InvalidPrivateFieldResolution, {
+ at: loc
+ }, name);
+ }
+ }
+ }
+
+ declarePrivateName(name, elementType, loc) {
+ const {
+ privateNames,
+ loneAccessors,
+ undefinedPrivateNames
+ } = this.current();
+ let redefined = privateNames.has(name);
+
+ if (elementType & CLASS_ELEMENT_KIND_ACCESSOR) {
+ const accessor = redefined && loneAccessors.get(name);
+
+ if (accessor) {
+ const oldStatic = accessor & CLASS_ELEMENT_FLAG_STATIC;
+ const newStatic = elementType & CLASS_ELEMENT_FLAG_STATIC;
+ const oldKind = accessor & CLASS_ELEMENT_KIND_ACCESSOR;
+ const newKind = elementType & CLASS_ELEMENT_KIND_ACCESSOR;
+ redefined = oldKind === newKind || oldStatic !== newStatic;
+ if (!redefined) loneAccessors.delete(name);
+ } else if (!redefined) {
+ loneAccessors.set(name, elementType);
+ }
+ }
+
+ if (redefined) {
+ this.raise(ErrorMessages.PrivateNameRedeclaration, {
+ at: loc
+ }, name);
+ }
+
+ privateNames.add(name);
+ undefinedPrivateNames.delete(name);
+ }
+
+ usePrivateName(name, loc) {
+ let classScope;
+
+ for (classScope of this.stack) {
+ if (classScope.privateNames.has(name)) return;
+ }
+
+ if (classScope) {
+ classScope.undefinedPrivateNames.set(name, loc);
+ } else {
+ this.raise(ErrorMessages.InvalidPrivateFieldResolution, {
+ at: loc
+ }, name);
+ }
+ }
+
+}
+
+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(message, loc) {
+ this.errors.set(loc.index, {
+ message,
+ loc
+ });
+ }
+
+ clearDeclarationError(loc) {
+ this.errors.delete(loc.index);
+ }
+
+ 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(loc, template) {
+ const {
+ stack
+ } = this;
+ let i = stack.length - 1;
+ let scope = stack[i];
+
+ while (!scope.isCertainlyParameterDeclaration()) {
+ if (scope.canBeArrowParameterDeclaration()) {
+ scope.recordDeclarationError(template, loc);
+ } else {
+ return;
+ }
+
+ scope = stack[--i];
+ }
+
+ this.raise(template, {
+ at: loc
+ });
+ }
+
+ recordParenthesizedIdentifierError(template, loc) {
+ const {
+ stack
+ } = this;
+ const scope = stack[stack.length - 1];
+
+ if (scope.isCertainlyParameterDeclaration()) {
+ this.raise(template, {
+ at: loc
+ });
+ } else if (scope.canBeArrowParameterDeclaration()) {
+ scope.recordDeclarationError(template, loc);
+ } else {
+ return;
+ }
+ }
+
+ recordAsyncArrowParametersError(template, loc) {
+ const {
+ stack
+ } = this;
+ let i = stack.length - 1;
+ let scope = stack[i];
+
+ while (scope.canBeArrowParameterDeclaration()) {
+ if (scope.type === kMaybeAsyncArrowParameterDeclaration) {
+ scope.recordDeclarationError(template, loc);
+ }
+
+ scope = stack[--i];
+ }
+ }
+
+ validateAsPattern() {
+ const {
+ stack
+ } = this;
+ const currentScope = stack[stack.length - 1];
+ if (!currentScope.canBeArrowParameterDeclaration()) return;
+ currentScope.iterateErrors(({
+ message,
+ loc
+ }) => {
+ this.raise(message, {
+ at: loc
+ });
+ let i = stack.length - 2;
+ let scope = stack[i];
+
+ while (scope.canBeArrowParameterDeclaration()) {
+ scope.clearDeclarationError(loc);
+ scope = stack[--i];
+ }
+ });
+ }
+
+}
+function newParameterDeclarationScope() {
+ return new ExpressionScope(kParameterDeclaration);
+}
+function newArrowHeadScope() {
+ return new ArrowHeadParsingScope(kMaybeArrowParameterDeclaration);
+}
+function newAsyncArrowScope() {
+ return new ArrowHeadParsingScope(kMaybeAsyncArrowParameterDeclaration);
+}
+function newExpressionScope() {
+ return new ExpressionScope();
+}
+
+const PARAM = 0b0000,
+ PARAM_YIELD = 0b0001,
+ PARAM_AWAIT = 0b0010,
+ PARAM_RETURN = 0b0100,
+ PARAM_IN = 0b1000;
+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;
+ }
+
+}
+function functionFlags(isAsync, isGenerator) {
+ return (isAsync ? PARAM_AWAIT : 0) | (isGenerator ? PARAM_YIELD : 0);
+}
+
+class UtilParser extends Tokenizer {
+ addExtra(node, key, value, enumerable = true) {
+ if (!node) return;
+ const extra = node.extra = node.extra || {};
+
+ if (enumerable) {
+ extra[key] = value;
+ } else {
+ Object.defineProperty(extra, key, {
+ enumerable,
+ value
+ });
+ }
+ }
+
+ isContextual(token) {
+ return this.state.type === token && !this.state.containsEsc;
+ }
+
+ isUnparsedContextual(nameStart, name) {
+ const nameEnd = nameStart + name.length;
+
+ if (this.input.slice(nameStart, nameEnd) === name) {
+ const nextCh = this.input.charCodeAt(nameEnd);
+ return !(isIdentifierChar(nextCh) || (nextCh & 0xfc00) === 0xd800);
+ }
+
+ return false;
+ }
+
+ isLookaheadContextual(name) {
+ const next = this.nextTokenStart();
+ return this.isUnparsedContextual(next, name);
+ }
+
+ eatContextual(token) {
+ if (this.isContextual(token)) {
+ this.next();
+ return true;
+ }
+
+ return false;
+ }
+
+ expectContextual(token, template) {
+ if (!this.eatContextual(token)) {
+ if (template != null) {
+ throw this.raise(template, {
+ at: this.state.startLoc
+ });
+ }
+
+ throw this.unexpected(null, token);
+ }
+ }
+
+ canInsertSemicolon() {
+ return this.match(135) || this.match(8) || this.hasPrecedingLineBreak();
+ }
+
+ hasPrecedingLineBreak() {
+ return lineBreak.test(this.input.slice(this.state.lastTokEndLoc.index, this.state.start));
+ }
+
+ hasFollowingLineBreak() {
+ skipWhiteSpaceToLineBreak.lastIndex = this.state.end;
+ return skipWhiteSpaceToLineBreak.test(this.input);
+ }
+
+ isLineTerminator() {
+ return this.eat(13) || this.canInsertSemicolon();
+ }
+
+ semicolon(allowAsi = true) {
+ if (allowAsi ? this.isLineTerminator() : this.eat(13)) return;
+ this.raise(ErrorMessages.MissingSemicolon, {
+ at: this.state.lastTokEndLoc
+ });
+ }
+
+ expect(type, loc) {
+ this.eat(type) || this.unexpected(loc, type);
+ }
+
+ assertNoSpace(message = "Unexpected space.") {
+ if (this.state.start > this.state.lastTokEndLoc.index) {
+ this.raise({
+ code: ErrorCodes.SyntaxError,
+ reasonCode: "UnexpectedSpace",
+ template: message
+ }, {
+ at: this.state.lastTokEndLoc
+ });
+ }
+ }
+
+ unexpected(loc, type) {
+ throw this.raise({
+ code: ErrorCodes.SyntaxError,
+ reasonCode: "UnexpectedToken",
+ template: type != null ? `Unexpected token, expected "${tokenLabelName(type)}"` : "Unexpected token"
+ }, {
+ at: loc != null ? loc : this.state.startLoc
+ });
+ }
+
+ getPluginNamesFromConfigs(pluginConfigs) {
+ return pluginConfigs.map(c => {
+ if (typeof c === "string") {
+ return c;
+ } else {
+ return c[0];
+ }
+ });
+ }
+
+ expectPlugin(pluginConfig, loc) {
+ if (!this.hasPlugin(pluginConfig)) {
+ throw this.raiseWithData(loc != null ? loc : this.state.startLoc, {
+ missingPlugin: this.getPluginNamesFromConfigs([pluginConfig])
+ }, `This experimental syntax requires enabling the parser plugin: ${JSON.stringify(pluginConfig)}.`);
+ }
+
+ return true;
+ }
+
+ expectOnePlugin(pluginConfigs) {
+ if (!pluginConfigs.some(c => this.hasPlugin(c))) {
+ throw this.raiseWithData(this.state.startLoc, {
+ missingPlugin: this.getPluginNamesFromConfigs(pluginConfigs)
+ }, `This experimental syntax requires enabling one of the following parser plugin(s): ${pluginConfigs.map(c => JSON.stringify(c)).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;
+ this.state.tokensLength = failState.tokensLength;
+ 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 {
+ shorthandAssignLoc,
+ doubleProtoLoc,
+ privateKeyLoc,
+ optionalParametersLoc
+ } = refExpressionErrors;
+ const hasErrors = !!shorthandAssignLoc || !!doubleProtoLoc || !!optionalParametersLoc || !!privateKeyLoc;
+
+ if (!andThrow) {
+ return hasErrors;
+ }
+
+ if (shorthandAssignLoc != null) {
+ this.raise(ErrorMessages.InvalidCoverInitializedName, {
+ at: shorthandAssignLoc
+ });
+ }
+
+ if (doubleProtoLoc != null) {
+ this.raise(ErrorMessages.DuplicateProto, {
+ at: doubleProtoLoc
+ });
+ }
+
+ if (privateKeyLoc != null) {
+ this.raise(ErrorMessages.UnexpectedPrivateField, {
+ at: privateKeyLoc
+ });
+ }
+
+ if (optionalParametersLoc != null) {
+ this.unexpected(optionalParametersLoc);
+ }
+ }
+
+ isLiteralPropertyName() {
+ return tokenIsLiteralPropertyName(this.state.type);
+ }
+
+ isPrivateName(node) {
+ return node.type === "PrivateName";
+ }
+
+ getPrivateNameSV(node) {
+ return node.id.name;
+ }
+
+ hasPropertyAsPrivateName(node) {
+ return (node.type === "MemberExpression" || node.type === "OptionalMemberExpression") && this.isPrivateName(node.property);
+ }
+
+ isOptionalChain(node) {
+ return node.type === "OptionalMemberExpression" || node.type === "OptionalCallExpression";
+ }
+
+ isObjectProperty(node) {
+ return node.type === "ObjectProperty";
+ }
+
+ isObjectMethod(node) {
+ return node.type === "ObjectMethod";
+ }
+
+ initializeScopes(inModule = this.options.sourceType === "module") {
+ const oldLabels = this.state.labels;
+ this.state.labels = [];
+ const oldExportedIdentifiers = this.exportedIdentifiers;
+ this.exportedIdentifiers = new Set();
+ const oldInModule = this.inModule;
+ this.inModule = inModule;
+ const oldScope = this.scope;
+ const ScopeHandler = this.getScopeHandler();
+ this.scope = new ScopeHandler(this.raise.bind(this), this.inModule);
+ const oldProdParam = this.prodParam;
+ this.prodParam = new ProductionParameterHandler();
+ const oldClassScope = this.classScope;
+ this.classScope = new ClassScopeHandler(this.raise.bind(this));
+ const oldExpressionScope = this.expressionScope;
+ this.expressionScope = new ExpressionScopeHandler(this.raise.bind(this));
+ return () => {
+ this.state.labels = oldLabels;
+ this.exportedIdentifiers = oldExportedIdentifiers;
+ this.inModule = oldInModule;
+ this.scope = oldScope;
+ this.prodParam = oldProdParam;
+ this.classScope = oldClassScope;
+ this.expressionScope = oldExpressionScope;
+ };
+ }
+
+ enterInitialScopes() {
+ let paramFlags = PARAM;
+
+ if (this.inModule) {
+ paramFlags |= PARAM_AWAIT;
+ }
+
+ this.scope.enter(SCOPE_PROGRAM);
+ this.prodParam.enter(paramFlags);
+ }
+
+ checkDestructuringPrivate(refExpressionErrors) {
+ const {
+ privateKeyLoc
+ } = refExpressionErrors;
+
+ if (privateKeyLoc !== null) {
+ this.expectPlugin("destructuringPrivate", privateKeyLoc);
+ }
+ }
+
+}
+class ExpressionErrors {
+ constructor() {
+ this.shorthandAssignLoc = null;
+ this.doubleProtoLoc = null;
+ this.privateKeyLoc = null;
+ this.optionalParametersLoc = null;
+ }
+
+}
+
+class Node {
+ constructor(parser, pos, loc) {
+ this.type = "";
+ this.start = pos;
+ this.end = 0;
+ this.loc = new SourceLocation(loc);
+ if (parser != null && parser.options.ranges) this.range = [pos, 0];
+ if (parser != null && parser.filename) this.loc.filename = parser.filename;
+ }
+
+}
+
+const NodePrototype = Node.prototype;
+{
+ NodePrototype.__clone = function () {
+ 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;
+ };
+}
+
+function clonePlaceholder(node) {
+ return cloneIdentifier(node);
+}
+
+function cloneIdentifier(node) {
+ const {
+ type,
+ start,
+ end,
+ loc,
+ range,
+ extra,
+ name
+ } = node;
+ const cloned = Object.create(NodePrototype);
+ cloned.type = type;
+ cloned.start = start;
+ cloned.end = end;
+ cloned.loc = loc;
+ cloned.range = range;
+ cloned.extra = extra;
+ cloned.name = name;
+
+ if (type === "Placeholder") {
+ cloned.expectedNode = node.expectedNode;
+ }
+
+ return cloned;
+}
+function cloneStringLiteral(node) {
+ const {
+ type,
+ start,
+ end,
+ loc,
+ range,
+ extra
+ } = node;
+
+ if (type === "Placeholder") {
+ return clonePlaceholder(node);
+ }
+
+ const cloned = Object.create(NodePrototype);
+ cloned.type = type;
+ cloned.start = start;
+ cloned.end = end;
+ cloned.loc = loc;
+ cloned.range = range;
+
+ if (node.raw !== undefined) {
+ cloned.raw = node.raw;
+ } else {
+ cloned.extra = extra;
+ }
+
+ cloned.value = node.value;
+ return cloned;
+}
+class NodeUtils extends UtilParser {
+ 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.lastTokEndLoc);
+ }
+
+ finishNodeAt(node, type, endLoc) {
+
+ node.type = type;
+ node.end = endLoc.index;
+ node.loc.end = endLoc;
+ if (this.options.ranges) node.range[1] = endLoc.index;
+ if (this.options.attachComment) 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, endLoc = this.state.lastTokEndLoc) {
+ node.end = endLoc.index;
+ node.loc.end = endLoc;
+ if (this.options.ranges) node.range[1] = endLoc.index;
+ }
+
+ resetStartLocationFromNode(node, locationNode) {
+ this.resetStartLocation(node, locationNode.start, locationNode.loc.start);
+ }
+
+}
+
+const reservedTypes = new Set(["_", "any", "bool", "boolean", "empty", "extends", "false", "interface", "mixed", "null", "number", "static", "string", "true", "typeof", "void"]);
+const FlowErrors = makeErrorTemplates({
+ AmbiguousConditionalArrow: "Ambiguous expression: wrap the arrow functions in parentheses to disambiguate.",
+ AmbiguousDeclareModuleKind: "Found both `declare module.exports` and `declare export` in the same module. Modules can only have 1 since they are either an ES module or they are a CommonJS module.",
+ AssignReservedType: "Cannot overwrite reserved type %0.",
+ DeclareClassElement: "The `declare` modifier can only appear on class fields.",
+ DeclareClassFieldInitializer: "Initializers are not allowed in fields with the `declare` modifier.",
+ DuplicateDeclareModuleExports: "Duplicate `declare module.exports` statement.",
+ EnumBooleanMemberNotInitialized: "Boolean enum members need to be initialized. Use either `%0 = true,` or `%0 = false,` in enum `%1`.",
+ EnumDuplicateMemberName: "Enum member names need to be unique, but the name `%0` has already been used before in enum `%1`.",
+ EnumInconsistentMemberValues: "Enum `%0` has inconsistent member initializers. Either use no initializers, or consistently use literals (either booleans, numbers, or strings) for all member initializers.",
+ EnumInvalidExplicitType: "Enum type `%1` is not valid. Use one of `boolean`, `number`, `string`, or `symbol` in enum `%0`.",
+ EnumInvalidExplicitTypeUnknownSupplied: "Supplied enum type is not valid. Use one of `boolean`, `number`, `string`, or `symbol` in enum `%0`.",
+ EnumInvalidMemberInitializerPrimaryType: "Enum `%0` has type `%2`, so the initializer of `%1` needs to be a %2 literal.",
+ EnumInvalidMemberInitializerSymbolType: "Symbol enum members cannot be initialized. Use `%1,` in enum `%0`.",
+ EnumInvalidMemberInitializerUnknownType: "The enum member initializer for `%1` needs to be a literal (either a boolean, number, or string) in enum `%0`.",
+ EnumInvalidMemberName: "Enum member names cannot start with lowercase 'a' through 'z'. Instead of using `%0`, consider using `%1`, in enum `%2`.",
+ EnumNumberMemberNotInitialized: "Number enum members need to be initialized, e.g. `%1 = 1` in enum `%0`.",
+ EnumStringMemberInconsistentlyInitailized: "String enum members need to consistently either all use initializers, or use no initializers, in enum `%0`.",
+ GetterMayNotHaveThisParam: "A getter cannot have a `this` parameter.",
+ ImportTypeShorthandOnlyInPureImport: "The `type` and `typeof` keywords on named imports can only be used on regular `import` statements. It cannot be used with `import type` or `import typeof` statements.",
+ InexactInsideExact: "Explicit inexact syntax cannot appear inside an explicit exact object type.",
+ InexactInsideNonObject: "Explicit inexact syntax cannot appear in class or interface definitions.",
+ InexactVariance: "Explicit inexact syntax cannot have variance.",
+ InvalidNonTypeImportInDeclareModule: "Imports within a `declare module` body must always be `import type` or `import typeof`.",
+ MissingTypeParamDefault: "Type parameter declaration needs a default, since a preceding type parameter declaration has a default.",
+ NestedDeclareModule: "`declare module` cannot be used inside another `declare module`.",
+ NestedFlowComment: "Cannot have a flow comment inside another flow comment.",
+ PatternIsOptional: "A binding pattern parameter cannot be optional in an implementation signature.",
+ SetterMayNotHaveThisParam: "A setter cannot have a `this` parameter.",
+ SpreadVariance: "Spread properties cannot have variance.",
+ ThisParamAnnotationRequired: "A type annotation is required for the `this` parameter.",
+ ThisParamBannedInConstructor: "Constructors cannot have a `this` parameter; constructors don't bind `this` like other functions.",
+ ThisParamMayNotBeOptional: "The `this` parameter cannot be optional.",
+ ThisParamMustBeFirst: "The `this` parameter must be the first function parameter.",
+ ThisParamNoDefault: "The `this` parameter may not have a default value.",
+ TypeBeforeInitializer: "Type annotations must come before default assignments, e.g. instead of `age = 25: number` use `age: number = 25`.",
+ TypeCastInPattern: "The type cast expression is expected to be wrapped with parenthesis.",
+ UnexpectedExplicitInexactInObject: "Explicit inexact syntax must appear at the end of an inexact object.",
+ UnexpectedReservedType: "Unexpected reserved type %0.",
+ UnexpectedReservedUnderscore: "`_` is only allowed as a type argument to call or new.",
+ UnexpectedSpaceBetweenModuloChecks: "Spaces between `%` and `checks` are not allowed here.",
+ UnexpectedSpreadType: "Spread operator cannot appear in class or interface definitions.",
+ UnexpectedSubtractionOperand: 'Unexpected token, expected "number" or "bigint".',
+ UnexpectedTokenAfterTypeParameter: "Expected an arrow function after this type parameter declaration.",
+ UnexpectedTypeParameterBeforeAsyncArrowFunction: "Type parameters must come after the async keyword, e.g. instead of ` async () => {}`, use `async () => {}`.",
+ UnsupportedDeclareExportKind: "`declare export %0` is not supported. Use `%1` instead.",
+ UnsupportedStatementInDeclareModule: "Only declares and type imports are allowed inside declare module.",
+ UnterminatedFlowComment: "Unterminated flow-comment."
+}, ErrorCodes.SyntaxError, "flow");
+
+function isEsModuleType(bodyElement) {
+ return bodyElement.type === "DeclareExportAllDeclaration" || bodyElement.type === "DeclareExportDeclaration" && (!bodyElement.declaration || bodyElement.declaration.type !== "TypeAlias" && bodyElement.declaration.type !== "InterfaceDeclaration");
+}
+
+function hasTypeImportKind(node) {
+ return node.importKind === "type" || node.importKind === "typeof";
+}
+
+function isMaybeDefaultImport(type) {
+ return tokenIsKeywordOrIdentifier(type) && type !== 97;
+}
+
+const exportSuggestions = {
+ const: "declare export var",
+ let: "declare export var",
+ type: "export type",
+ interface: "export interface"
+};
+
+function partition(list, test) {
+ const list1 = [];
+ const list2 = [];
+
+ for (let i = 0; i < list.length; i++) {
+ (test(list[i], i, list) ? list1 : list2).push(list[i]);
+ }
+
+ return [list1, list2];
+}
+
+const FLOW_PRAGMA_REGEX = /\*?\s*@((?:no)?flow)\b/;
+var flow = (superClass => class extends superClass {
+ constructor(...args) {
+ super(...args);
+ this.flowPragma = undefined;
+ }
+
+ getScopeHandler() {
+ return FlowScopeHandler;
+ }
+
+ shouldParseTypes() {
+ return this.getPluginOption("flow", "all") || this.flowPragma === "flow";
+ }
+
+ shouldParseEnums() {
+ return !!this.getPluginOption("flow", "enums");
+ }
+
+ finishToken(type, val) {
+ if (type !== 129 && type !== 13 && type !== 28) {
+ if (this.flowPragma === undefined) {
+ this.flowPragma = null;
+ }
+ }
+
+ return super.finishToken(type, val);
+ }
+
+ addComment(comment) {
+ if (this.flowPragma === undefined) {
+ const matches = FLOW_PRAGMA_REGEX.exec(comment.value);
+
+ if (!matches) ; else if (matches[1] === "flow") {
+ this.flowPragma = "flow";
+ } else if (matches[1] === "noflow") {
+ this.flowPragma = "noflow";
+ } else {
+ throw new Error("Unexpected flow pragma");
+ }
+ }
+
+ return super.addComment(comment);
+ }
+
+ flowParseTypeInitialiser(tok) {
+ const oldInType = this.state.inType;
+ this.state.inType = true;
+ this.expect(tok || 14);
+ const type = this.flowParseType();
+ this.state.inType = oldInType;
+ return type;
+ }
+
+ flowParsePredicate() {
+ const node = this.startNode();
+ const moduloLoc = this.state.startLoc;
+ this.next();
+ this.expectContextual(107);
+
+ if (this.state.lastTokStart > moduloLoc.index + 1) {
+ this.raise(FlowErrors.UnexpectedSpaceBetweenModuloChecks, {
+ at: moduloLoc
+ });
+ }
+
+ if (this.eat(10)) {
+ node.value = this.parseExpression();
+ this.expect(11);
+ return this.finishNode(node, "DeclaredPredicate");
+ } else {
+ return this.finishNode(node, "InferredPredicate");
+ }
+ }
+
+ flowParseTypeAndPredicateInitialiser() {
+ const oldInType = this.state.inType;
+ this.state.inType = true;
+ this.expect(14);
+ let type = null;
+ let predicate = null;
+
+ if (this.match(54)) {
+ this.state.inType = oldInType;
+ predicate = this.flowParsePredicate();
+ } else {
+ type = this.flowParseType();
+ this.state.inType = oldInType;
+
+ if (this.match(54)) {
+ predicate = this.flowParsePredicate();
+ }
+ }
+
+ return [type, predicate];
+ }
+
+ flowParseDeclareClass(node) {
+ this.next();
+ this.flowParseInterfaceish(node, true);
+ return this.finishNode(node, "DeclareClass");
+ }
+
+ flowParseDeclareFunction(node) {
+ this.next();
+ const id = node.id = this.parseIdentifier();
+ const typeNode = this.startNode();
+ const typeContainer = this.startNode();
+
+ if (this.match(47)) {
+ typeNode.typeParameters = this.flowParseTypeParameterDeclaration();
+ } else {
+ typeNode.typeParameters = null;
+ }
+
+ this.expect(10);
+ const tmp = this.flowParseFunctionTypeParams();
+ typeNode.params = tmp.params;
+ typeNode.rest = tmp.rest;
+ typeNode.this = tmp._this;
+ this.expect(11);
+ [typeNode.returnType, node.predicate] = this.flowParseTypeAndPredicateInitialiser();
+ typeContainer.typeAnnotation = this.finishNode(typeNode, "FunctionTypeAnnotation");
+ id.typeAnnotation = this.finishNode(typeContainer, "TypeAnnotation");
+ this.resetEndLocation(id);
+ this.semicolon();
+ this.scope.declareName(node.id.name, BIND_FLOW_DECLARE_FN, node.id.loc.start);
+ return this.finishNode(node, "DeclareFunction");
+ }
+
+ flowParseDeclare(node, insideModule) {
+ if (this.match(80)) {
+ return this.flowParseDeclareClass(node);
+ } else if (this.match(68)) {
+ return this.flowParseDeclareFunction(node);
+ } else if (this.match(74)) {
+ return this.flowParseDeclareVariable(node);
+ } else if (this.eatContextual(123)) {
+ if (this.match(16)) {
+ return this.flowParseDeclareModuleExports(node);
+ } else {
+ if (insideModule) {
+ this.raise(FlowErrors.NestedDeclareModule, {
+ at: this.state.lastTokStartLoc
+ });
+ }
+
+ return this.flowParseDeclareModule(node);
+ }
+ } else if (this.isContextual(126)) {
+ return this.flowParseDeclareTypeAlias(node);
+ } else if (this.isContextual(127)) {
+ return this.flowParseDeclareOpaqueType(node);
+ } else if (this.isContextual(125)) {
+ return this.flowParseDeclareInterface(node);
+ } else if (this.match(82)) {
+ return this.flowParseDeclareExportDeclaration(node, insideModule);
+ } else {
+ throw this.unexpected();
+ }
+ }
+
+ flowParseDeclareVariable(node) {
+ this.next();
+ node.id = this.flowParseTypeAnnotatableIdentifier(true);
+ this.scope.declareName(node.id.name, BIND_VAR, node.id.loc.start);
+ this.semicolon();
+ return this.finishNode(node, "DeclareVariable");
+ }
+
+ flowParseDeclareModule(node) {
+ this.scope.enter(SCOPE_OTHER);
+
+ if (this.match(129)) {
+ node.id = this.parseExprAtom();
+ } else {
+ node.id = this.parseIdentifier();
+ }
+
+ const bodyNode = node.body = this.startNode();
+ const body = bodyNode.body = [];
+ this.expect(5);
+
+ while (!this.match(8)) {
+ let bodyNode = this.startNode();
+
+ if (this.match(83)) {
+ this.next();
+
+ if (!this.isContextual(126) && !this.match(87)) {
+ this.raise(FlowErrors.InvalidNonTypeImportInDeclareModule, {
+ at: this.state.lastTokStartLoc
+ });
+ }
+
+ this.parseImport(bodyNode);
+ } else {
+ this.expectContextual(121, FlowErrors.UnsupportedStatementInDeclareModule);
+ bodyNode = this.flowParseDeclare(bodyNode, true);
+ }
+
+ body.push(bodyNode);
+ }
+
+ this.scope.exit();
+ this.expect(8);
+ this.finishNode(bodyNode, "BlockStatement");
+ let kind = null;
+ let hasModuleExport = false;
+ body.forEach(bodyElement => {
+ if (isEsModuleType(bodyElement)) {
+ if (kind === "CommonJS") {
+ this.raise(FlowErrors.AmbiguousDeclareModuleKind, {
+ node: bodyElement
+ });
+ }
+
+ kind = "ES";
+ } else if (bodyElement.type === "DeclareModuleExports") {
+ if (hasModuleExport) {
+ this.raise(FlowErrors.DuplicateDeclareModuleExports, {
+ node: bodyElement
+ });
+ }
+
+ if (kind === "ES") {
+ this.raise(FlowErrors.AmbiguousDeclareModuleKind, {
+ node: bodyElement
+ });
+ }
+
+ kind = "CommonJS";
+ hasModuleExport = true;
+ }
+ });
+ node.kind = kind || "CommonJS";
+ return this.finishNode(node, "DeclareModule");
+ }
+
+ flowParseDeclareExportDeclaration(node, insideModule) {
+ this.expect(82);
+
+ if (this.eat(65)) {
+ if (this.match(68) || this.match(80)) {
+ node.declaration = this.flowParseDeclare(this.startNode());
+ } else {
+ node.declaration = this.flowParseType();
+ this.semicolon();
+ }
+
+ node.default = true;
+ return this.finishNode(node, "DeclareExportDeclaration");
+ } else {
+ if (this.match(75) || this.isLet() || (this.isContextual(126) || this.isContextual(125)) && !insideModule) {
+ const label = this.state.value;
+ const suggestion = exportSuggestions[label];
+ throw this.raise(FlowErrors.UnsupportedDeclareExportKind, {
+ at: this.state.startLoc
+ }, label, suggestion);
+ }
+
+ if (this.match(74) || this.match(68) || this.match(80) || this.isContextual(127)) {
+ node.declaration = this.flowParseDeclare(this.startNode());
+ node.default = false;
+ return this.finishNode(node, "DeclareExportDeclaration");
+ } else if (this.match(55) || this.match(5) || this.isContextual(125) || this.isContextual(126) || this.isContextual(127)) {
+ node = this.parseExport(node);
+
+ if (node.type === "ExportNamedDeclaration") {
+ node.type = "ExportDeclaration";
+ node.default = false;
+ delete node.exportKind;
+ }
+
+ node.type = "Declare" + node.type;
+ return node;
+ }
+ }
+
+ throw this.unexpected();
+ }
+
+ flowParseDeclareModuleExports(node) {
+ this.next();
+ this.expectContextual(108);
+ node.typeAnnotation = this.flowParseTypeAnnotation();
+ this.semicolon();
+ return this.finishNode(node, "DeclareModuleExports");
+ }
+
+ flowParseDeclareTypeAlias(node) {
+ this.next();
+ this.flowParseTypeAlias(node);
+ node.type = "DeclareTypeAlias";
+ return node;
+ }
+
+ flowParseDeclareOpaqueType(node) {
+ this.next();
+ this.flowParseOpaqueType(node, true);
+ node.type = "DeclareOpaqueType";
+ return node;
+ }
+
+ flowParseDeclareInterface(node) {
+ this.next();
+ this.flowParseInterfaceish(node);
+ return this.finishNode(node, "DeclareInterface");
+ }
+
+ flowParseInterfaceish(node, isClass = false) {
+ node.id = this.flowParseRestrictedIdentifier(!isClass, true);
+ this.scope.declareName(node.id.name, isClass ? BIND_FUNCTION : BIND_LEXICAL, node.id.loc.start);
+
+ if (this.match(47)) {
+ node.typeParameters = this.flowParseTypeParameterDeclaration();
+ } else {
+ node.typeParameters = null;
+ }
+
+ node.extends = [];
+ node.implements = [];
+ node.mixins = [];
+
+ if (this.eat(81)) {
+ do {
+ node.extends.push(this.flowParseInterfaceExtends());
+ } while (!isClass && this.eat(12));
+ }
+
+ if (this.isContextual(114)) {
+ this.next();
+
+ do {
+ node.mixins.push(this.flowParseInterfaceExtends());
+ } while (this.eat(12));
+ }
+
+ if (this.isContextual(110)) {
+ this.next();
+
+ do {
+ node.implements.push(this.flowParseInterfaceExtends());
+ } while (this.eat(12));
+ }
+
+ node.body = this.flowParseObjectType({
+ allowStatic: isClass,
+ allowExact: false,
+ allowSpread: false,
+ allowProto: isClass,
+ allowInexact: false
+ });
+ }
+
+ flowParseInterfaceExtends() {
+ const node = this.startNode();
+ node.id = this.flowParseQualifiedTypeIdentifier();
+
+ if (this.match(47)) {
+ node.typeParameters = this.flowParseTypeParameterInstantiation();
+ } else {
+ node.typeParameters = null;
+ }
+
+ return this.finishNode(node, "InterfaceExtends");
+ }
+
+ flowParseInterface(node) {
+ this.flowParseInterfaceish(node);
+ return this.finishNode(node, "InterfaceDeclaration");
+ }
+
+ checkNotUnderscore(word) {
+ if (word === "_") {
+ this.raise(FlowErrors.UnexpectedReservedUnderscore, {
+ at: this.state.startLoc
+ });
+ }
+ }
+
+ checkReservedType(word, startLoc, declaration) {
+ if (!reservedTypes.has(word)) return;
+ this.raise(declaration ? FlowErrors.AssignReservedType : FlowErrors.UnexpectedReservedType, {
+ at: startLoc
+ }, word);
+ }
+
+ flowParseRestrictedIdentifier(liberal, declaration) {
+ this.checkReservedType(this.state.value, this.state.startLoc, declaration);
+ return this.parseIdentifier(liberal);
+ }
+
+ flowParseTypeAlias(node) {
+ node.id = this.flowParseRestrictedIdentifier(false, true);
+ this.scope.declareName(node.id.name, BIND_LEXICAL, node.id.loc.start);
+
+ if (this.match(47)) {
+ node.typeParameters = this.flowParseTypeParameterDeclaration();
+ } else {
+ node.typeParameters = null;
+ }
+
+ node.right = this.flowParseTypeInitialiser(29);
+ this.semicolon();
+ return this.finishNode(node, "TypeAlias");
+ }
+
+ flowParseOpaqueType(node, declare) {
+ this.expectContextual(126);
+ node.id = this.flowParseRestrictedIdentifier(true, true);
+ this.scope.declareName(node.id.name, BIND_LEXICAL, node.id.loc.start);
+
+ if (this.match(47)) {
+ node.typeParameters = this.flowParseTypeParameterDeclaration();
+ } else {
+ node.typeParameters = null;
+ }
+
+ node.supertype = null;
+
+ if (this.match(14)) {
+ node.supertype = this.flowParseTypeInitialiser(14);
+ }
+
+ node.impltype = null;
+
+ if (!declare) {
+ node.impltype = this.flowParseTypeInitialiser(29);
+ }
+
+ this.semicolon();
+ return this.finishNode(node, "OpaqueType");
+ }
+
+ flowParseTypeParameter(requireDefault = false) {
+ const nodeStartLoc = this.state.startLoc;
+ const node = this.startNode();
+ const variance = this.flowParseVariance();
+ const ident = this.flowParseTypeAnnotatableIdentifier();
+ node.name = ident.name;
+ node.variance = variance;
+ node.bound = ident.typeAnnotation;
+
+ if (this.match(29)) {
+ this.eat(29);
+ node.default = this.flowParseType();
+ } else {
+ if (requireDefault) {
+ this.raise(FlowErrors.MissingTypeParamDefault, {
+ at: nodeStartLoc
+ });
+ }
+ }
+
+ return this.finishNode(node, "TypeParameter");
+ }
+
+ flowParseTypeParameterDeclaration() {
+ const oldInType = this.state.inType;
+ const node = this.startNode();
+ node.params = [];
+ this.state.inType = true;
+
+ if (this.match(47) || this.match(138)) {
+ this.next();
+ } else {
+ this.unexpected();
+ }
+
+ let defaultRequired = false;
+
+ do {
+ const typeParameter = this.flowParseTypeParameter(defaultRequired);
+ node.params.push(typeParameter);
+
+ if (typeParameter.default) {
+ defaultRequired = true;
+ }
+
+ if (!this.match(48)) {
+ this.expect(12);
+ }
+ } while (!this.match(48));
+
+ this.expect(48);
+ this.state.inType = oldInType;
+ return this.finishNode(node, "TypeParameterDeclaration");
+ }
+
+ flowParseTypeParameterInstantiation() {
+ const node = this.startNode();
+ const oldInType = this.state.inType;
+ node.params = [];
+ this.state.inType = true;
+ this.expect(47);
+ const oldNoAnonFunctionType = this.state.noAnonFunctionType;
+ this.state.noAnonFunctionType = false;
+
+ while (!this.match(48)) {
+ node.params.push(this.flowParseType());
+
+ if (!this.match(48)) {
+ this.expect(12);
+ }
+ }
+
+ this.state.noAnonFunctionType = oldNoAnonFunctionType;
+ this.expect(48);
+ this.state.inType = oldInType;
+ return this.finishNode(node, "TypeParameterInstantiation");
+ }
+
+ flowParseTypeParameterInstantiationCallOrNew() {
+ const node = this.startNode();
+ const oldInType = this.state.inType;
+ node.params = [];
+ this.state.inType = true;
+ this.expect(47);
+
+ while (!this.match(48)) {
+ node.params.push(this.flowParseTypeOrImplicitInstantiation());
+
+ if (!this.match(48)) {
+ this.expect(12);
+ }
+ }
+
+ this.expect(48);
+ this.state.inType = oldInType;
+ return this.finishNode(node, "TypeParameterInstantiation");
+ }
+
+ flowParseInterfaceType() {
+ const node = this.startNode();
+ this.expectContextual(125);
+ node.extends = [];
+
+ if (this.eat(81)) {
+ do {
+ node.extends.push(this.flowParseInterfaceExtends());
+ } while (this.eat(12));
+ }
+
+ node.body = this.flowParseObjectType({
+ allowStatic: false,
+ allowExact: false,
+ allowSpread: false,
+ allowProto: false,
+ allowInexact: false
+ });
+ return this.finishNode(node, "InterfaceTypeAnnotation");
+ }
+
+ flowParseObjectPropertyKey() {
+ return this.match(130) || this.match(129) ? this.parseExprAtom() : this.parseIdentifier(true);
+ }
+
+ flowParseObjectTypeIndexer(node, isStatic, variance) {
+ node.static = isStatic;
+
+ if (this.lookahead().type === 14) {
+ node.id = this.flowParseObjectPropertyKey();
+ node.key = this.flowParseTypeInitialiser();
+ } else {
+ node.id = null;
+ node.key = this.flowParseType();
+ }
+
+ this.expect(3);
+ node.value = this.flowParseTypeInitialiser();
+ node.variance = variance;
+ return this.finishNode(node, "ObjectTypeIndexer");
+ }
+
+ flowParseObjectTypeInternalSlot(node, isStatic) {
+ node.static = isStatic;
+ node.id = this.flowParseObjectPropertyKey();
+ this.expect(3);
+ this.expect(3);
+
+ if (this.match(47) || this.match(10)) {
+ node.method = true;
+ node.optional = false;
+ node.value = this.flowParseObjectTypeMethodish(this.startNodeAt(node.start, node.loc.start));
+ } else {
+ node.method = false;
+
+ if (this.eat(17)) {
+ node.optional = true;
+ }
+
+ node.value = this.flowParseTypeInitialiser();
+ }
+
+ return this.finishNode(node, "ObjectTypeInternalSlot");
+ }
+
+ flowParseObjectTypeMethodish(node) {
+ node.params = [];
+ node.rest = null;
+ node.typeParameters = null;
+ node.this = null;
+
+ if (this.match(47)) {
+ node.typeParameters = this.flowParseTypeParameterDeclaration();
+ }
+
+ this.expect(10);
+
+ if (this.match(78)) {
+ node.this = this.flowParseFunctionTypeParam(true);
+ node.this.name = null;
+
+ if (!this.match(11)) {
+ this.expect(12);
+ }
+ }
+
+ while (!this.match(11) && !this.match(21)) {
+ node.params.push(this.flowParseFunctionTypeParam(false));
+
+ if (!this.match(11)) {
+ this.expect(12);
+ }
+ }
+
+ if (this.eat(21)) {
+ node.rest = this.flowParseFunctionTypeParam(false);
+ }
+
+ this.expect(11);
+ node.returnType = this.flowParseTypeInitialiser();
+ return this.finishNode(node, "FunctionTypeAnnotation");
+ }
+
+ flowParseObjectTypeCallProperty(node, isStatic) {
+ const valueNode = this.startNode();
+ node.static = isStatic;
+ node.value = this.flowParseObjectTypeMethodish(valueNode);
+ return this.finishNode(node, "ObjectTypeCallProperty");
+ }
+
+ flowParseObjectType({
+ allowStatic,
+ allowExact,
+ allowSpread,
+ allowProto,
+ allowInexact
+ }) {
+ const oldInType = this.state.inType;
+ this.state.inType = true;
+ const nodeStart = this.startNode();
+ nodeStart.callProperties = [];
+ nodeStart.properties = [];
+ nodeStart.indexers = [];
+ nodeStart.internalSlots = [];
+ let endDelim;
+ let exact;
+ let inexact = false;
+
+ if (allowExact && this.match(6)) {
+ this.expect(6);
+ endDelim = 9;
+ exact = true;
+ } else {
+ this.expect(5);
+ endDelim = 8;
+ exact = false;
+ }
+
+ nodeStart.exact = exact;
+
+ while (!this.match(endDelim)) {
+ let isStatic = false;
+ let protoStartLoc = null;
+ let inexactStartLoc = null;
+ const node = this.startNode();
+
+ if (allowProto && this.isContextual(115)) {
+ const lookahead = this.lookahead();
+
+ if (lookahead.type !== 14 && lookahead.type !== 17) {
+ this.next();
+ protoStartLoc = this.state.startLoc;
+ allowStatic = false;
+ }
+ }
+
+ if (allowStatic && this.isContextual(104)) {
+ const lookahead = this.lookahead();
+
+ if (lookahead.type !== 14 && lookahead.type !== 17) {
+ this.next();
+ isStatic = true;
+ }
+ }
+
+ const variance = this.flowParseVariance();
+
+ if (this.eat(0)) {
+ if (protoStartLoc != null) {
+ this.unexpected(protoStartLoc);
+ }
+
+ if (this.eat(0)) {
+ if (variance) {
+ this.unexpected(variance.loc.start);
+ }
+
+ nodeStart.internalSlots.push(this.flowParseObjectTypeInternalSlot(node, isStatic));
+ } else {
+ nodeStart.indexers.push(this.flowParseObjectTypeIndexer(node, isStatic, variance));
+ }
+ } else if (this.match(10) || this.match(47)) {
+ if (protoStartLoc != null) {
+ this.unexpected(protoStartLoc);
+ }
+
+ if (variance) {
+ this.unexpected(variance.loc.start);
+ }
+
+ nodeStart.callProperties.push(this.flowParseObjectTypeCallProperty(node, isStatic));
+ } else {
+ let kind = "init";
+
+ if (this.isContextual(98) || this.isContextual(103)) {
+ const lookahead = this.lookahead();
+
+ if (tokenIsLiteralPropertyName(lookahead.type)) {
+ kind = this.state.value;
+ this.next();
+ }
+ }
+
+ const propOrInexact = this.flowParseObjectTypeProperty(node, isStatic, protoStartLoc, variance, kind, allowSpread, allowInexact != null ? allowInexact : !exact);
+
+ if (propOrInexact === null) {
+ inexact = true;
+ inexactStartLoc = this.state.lastTokStartLoc;
+ } else {
+ nodeStart.properties.push(propOrInexact);
+ }
+ }
+
+ this.flowObjectTypeSemicolon();
+
+ if (inexactStartLoc && !this.match(8) && !this.match(9)) {
+ this.raise(FlowErrors.UnexpectedExplicitInexactInObject, {
+ at: inexactStartLoc
+ });
+ }
+ }
+
+ this.expect(endDelim);
+
+ if (allowSpread) {
+ nodeStart.inexact = inexact;
+ }
+
+ const out = this.finishNode(nodeStart, "ObjectTypeAnnotation");
+ this.state.inType = oldInType;
+ return out;
+ }
+
+ flowParseObjectTypeProperty(node, isStatic, protoStartLoc, variance, kind, allowSpread, allowInexact) {
+ if (this.eat(21)) {
+ const isInexactToken = this.match(12) || this.match(13) || this.match(8) || this.match(9);
+
+ if (isInexactToken) {
+ if (!allowSpread) {
+ this.raise(FlowErrors.InexactInsideNonObject, {
+ at: this.state.lastTokStartLoc
+ });
+ } else if (!allowInexact) {
+ this.raise(FlowErrors.InexactInsideExact, {
+ at: this.state.lastTokStartLoc
+ });
+ }
+
+ if (variance) {
+ this.raise(FlowErrors.InexactVariance, {
+ node: variance
+ });
+ }
+
+ return null;
+ }
+
+ if (!allowSpread) {
+ this.raise(FlowErrors.UnexpectedSpreadType, {
+ at: this.state.lastTokStartLoc
+ });
+ }
+
+ if (protoStartLoc != null) {
+ this.unexpected(protoStartLoc);
+ }
+
+ if (variance) {
+ this.raise(FlowErrors.SpreadVariance, {
+ node: variance
+ });
+ }
+
+ node.argument = this.flowParseType();
+ return this.finishNode(node, "ObjectTypeSpreadProperty");
+ } else {
+ node.key = this.flowParseObjectPropertyKey();
+ node.static = isStatic;
+ node.proto = protoStartLoc != null;
+ node.kind = kind;
+ let optional = false;
+
+ if (this.match(47) || this.match(10)) {
+ node.method = true;
+
+ if (protoStartLoc != null) {
+ this.unexpected(protoStartLoc);
+ }
+
+ if (variance) {
+ this.unexpected(variance.loc.start);
+ }
+
+ node.value = this.flowParseObjectTypeMethodish(this.startNodeAt(node.start, node.loc.start));
+
+ if (kind === "get" || kind === "set") {
+ this.flowCheckGetterSetterParams(node);
+ }
+
+ if (!allowSpread && node.key.name === "constructor" && node.value.this) {
+ this.raise(FlowErrors.ThisParamBannedInConstructor, {
+ node: node.value.this
+ });
+ }
+ } else {
+ if (kind !== "init") this.unexpected();
+ node.method = false;
+
+ if (this.eat(17)) {
+ optional = true;
+ }
+
+ node.value = this.flowParseTypeInitialiser();
+ node.variance = variance;
+ }
+
+ node.optional = optional;
+ return this.finishNode(node, "ObjectTypeProperty");
+ }
+ }
+
+ flowCheckGetterSetterParams(property) {
+ const paramCount = property.kind === "get" ? 0 : 1;
+ const length = property.value.params.length + (property.value.rest ? 1 : 0);
+
+ if (property.value.this) {
+ this.raise(property.kind === "get" ? FlowErrors.GetterMayNotHaveThisParam : FlowErrors.SetterMayNotHaveThisParam, {
+ node: property.value.this
+ });
+ }
+
+ if (length !== paramCount) {
+ this.raise(property.kind === "get" ? ErrorMessages.BadGetterArity : ErrorMessages.BadSetterArity, {
+ node: property
+ });
+ }
+
+ if (property.kind === "set" && property.value.rest) {
+ this.raise(ErrorMessages.BadSetterRestParameter, {
+ node: property
+ });
+ }
+ }
+
+ flowObjectTypeSemicolon() {
+ if (!this.eat(13) && !this.eat(12) && !this.match(8) && !this.match(9)) {
+ this.unexpected();
+ }
+ }
+
+ flowParseQualifiedTypeIdentifier(startPos, startLoc, id) {
+ startPos = startPos || this.state.start;
+ startLoc = startLoc || this.state.startLoc;
+ let node = id || this.flowParseRestrictedIdentifier(true);
+
+ while (this.eat(16)) {
+ const node2 = this.startNodeAt(startPos, startLoc);
+ node2.qualification = node;
+ node2.id = this.flowParseRestrictedIdentifier(true);
+ node = this.finishNode(node2, "QualifiedTypeIdentifier");
+ }
+
+ return node;
+ }
+
+ flowParseGenericType(startPos, startLoc, id) {
+ const node = this.startNodeAt(startPos, startLoc);
+ node.typeParameters = null;
+ node.id = this.flowParseQualifiedTypeIdentifier(startPos, startLoc, id);
+
+ if (this.match(47)) {
+ node.typeParameters = this.flowParseTypeParameterInstantiation();
+ }
+
+ return this.finishNode(node, "GenericTypeAnnotation");
+ }
+
+ flowParseTypeofType() {
+ const node = this.startNode();
+ this.expect(87);
+ node.argument = this.flowParsePrimaryType();
+ return this.finishNode(node, "TypeofTypeAnnotation");
+ }
+
+ flowParseTupleType() {
+ const node = this.startNode();
+ node.types = [];
+ this.expect(0);
+
+ while (this.state.pos < this.length && !this.match(3)) {
+ node.types.push(this.flowParseType());
+ if (this.match(3)) break;
+ this.expect(12);
+ }
+
+ this.expect(3);
+ return this.finishNode(node, "TupleTypeAnnotation");
+ }
+
+ flowParseFunctionTypeParam(first) {
+ let name = null;
+ let optional = false;
+ let typeAnnotation = null;
+ const node = this.startNode();
+ const lh = this.lookahead();
+ const isThis = this.state.type === 78;
+
+ if (lh.type === 14 || lh.type === 17) {
+ if (isThis && !first) {
+ this.raise(FlowErrors.ThisParamMustBeFirst, {
+ node
+ });
+ }
+
+ name = this.parseIdentifier(isThis);
+
+ if (this.eat(17)) {
+ optional = true;
+
+ if (isThis) {
+ this.raise(FlowErrors.ThisParamMayNotBeOptional, {
+ node
+ });
+ }
+ }
+
+ typeAnnotation = this.flowParseTypeInitialiser();
+ } else {
+ typeAnnotation = this.flowParseType();
+ }
+
+ node.name = name;
+ node.optional = optional;
+ node.typeAnnotation = typeAnnotation;
+ return this.finishNode(node, "FunctionTypeParam");
+ }
+
+ reinterpretTypeAsFunctionTypeParam(type) {
+ const node = this.startNodeAt(type.start, type.loc.start);
+ node.name = null;
+ node.optional = false;
+ node.typeAnnotation = type;
+ return this.finishNode(node, "FunctionTypeParam");
+ }
+
+ flowParseFunctionTypeParams(params = []) {
+ let rest = null;
+ let _this = null;
+
+ if (this.match(78)) {
+ _this = this.flowParseFunctionTypeParam(true);
+ _this.name = null;
+
+ if (!this.match(11)) {
+ this.expect(12);
+ }
+ }
+
+ while (!this.match(11) && !this.match(21)) {
+ params.push(this.flowParseFunctionTypeParam(false));
+
+ if (!this.match(11)) {
+ this.expect(12);
+ }
+ }
+
+ if (this.eat(21)) {
+ rest = this.flowParseFunctionTypeParam(false);
+ }
+
+ return {
+ params,
+ rest,
+ _this
+ };
+ }
+
+ flowIdentToTypeAnnotation(startPos, startLoc, node, id) {
+ switch (id.name) {
+ case "any":
+ return this.finishNode(node, "AnyTypeAnnotation");
+
+ case "bool":
+ case "boolean":
+ return this.finishNode(node, "BooleanTypeAnnotation");
+
+ case "mixed":
+ return this.finishNode(node, "MixedTypeAnnotation");
+
+ case "empty":
+ return this.finishNode(node, "EmptyTypeAnnotation");
+
+ case "number":
+ return this.finishNode(node, "NumberTypeAnnotation");
+
+ case "string":
+ return this.finishNode(node, "StringTypeAnnotation");
+
+ case "symbol":
+ return this.finishNode(node, "SymbolTypeAnnotation");
+
+ default:
+ this.checkNotUnderscore(id.name);
+ return this.flowParseGenericType(startPos, startLoc, id);
+ }
+ }
+
+ flowParsePrimaryType() {
+ const startPos = this.state.start;
+ const startLoc = this.state.startLoc;
+ const node = this.startNode();
+ let tmp;
+ let type;
+ let isGroupedType = false;
+ const oldNoAnonFunctionType = this.state.noAnonFunctionType;
+
+ switch (this.state.type) {
+ case 5:
+ return this.flowParseObjectType({
+ allowStatic: false,
+ allowExact: false,
+ allowSpread: true,
+ allowProto: false,
+ allowInexact: true
+ });
+
+ case 6:
+ return this.flowParseObjectType({
+ allowStatic: false,
+ allowExact: true,
+ allowSpread: true,
+ allowProto: false,
+ allowInexact: false
+ });
+
+ case 0:
+ this.state.noAnonFunctionType = false;
+ type = this.flowParseTupleType();
+ this.state.noAnonFunctionType = oldNoAnonFunctionType;
+ return type;
+
+ case 47:
+ node.typeParameters = this.flowParseTypeParameterDeclaration();
+ this.expect(10);
+ tmp = this.flowParseFunctionTypeParams();
+ node.params = tmp.params;
+ node.rest = tmp.rest;
+ node.this = tmp._this;
+ this.expect(11);
+ this.expect(19);
+ node.returnType = this.flowParseType();
+ return this.finishNode(node, "FunctionTypeAnnotation");
+
+ case 10:
+ this.next();
+
+ if (!this.match(11) && !this.match(21)) {
+ if (tokenIsIdentifier(this.state.type) || this.match(78)) {
+ const token = this.lookahead().type;
+ isGroupedType = token !== 17 && token !== 14;
+ } else {
+ isGroupedType = true;
+ }
+ }
+
+ if (isGroupedType) {
+ this.state.noAnonFunctionType = false;
+ type = this.flowParseType();
+ this.state.noAnonFunctionType = oldNoAnonFunctionType;
+
+ if (this.state.noAnonFunctionType || !(this.match(12) || this.match(11) && this.lookahead().type === 19)) {
+ this.expect(11);
+ return type;
+ } else {
+ this.eat(12);
+ }
+ }
+
+ if (type) {
+ tmp = this.flowParseFunctionTypeParams([this.reinterpretTypeAsFunctionTypeParam(type)]);
+ } else {
+ tmp = this.flowParseFunctionTypeParams();
+ }
+
+ node.params = tmp.params;
+ node.rest = tmp.rest;
+ node.this = tmp._this;
+ this.expect(11);
+ this.expect(19);
+ node.returnType = this.flowParseType();
+ node.typeParameters = null;
+ return this.finishNode(node, "FunctionTypeAnnotation");
+
+ case 129:
+ return this.parseLiteral(this.state.value, "StringLiteralTypeAnnotation");
+
+ case 85:
+ case 86:
+ node.value = this.match(85);
+ this.next();
+ return this.finishNode(node, "BooleanLiteralTypeAnnotation");
+
+ case 53:
+ if (this.state.value === "-") {
+ this.next();
+
+ if (this.match(130)) {
+ return this.parseLiteralAtNode(-this.state.value, "NumberLiteralTypeAnnotation", node);
+ }
+
+ if (this.match(131)) {
+ return this.parseLiteralAtNode(-this.state.value, "BigIntLiteralTypeAnnotation", node);
+ }
+
+ throw this.raise(FlowErrors.UnexpectedSubtractionOperand, {
+ at: this.state.startLoc
+ });
+ }
+
+ throw this.unexpected();
+
+ case 130:
+ return this.parseLiteral(this.state.value, "NumberLiteralTypeAnnotation");
+
+ case 131:
+ return this.parseLiteral(this.state.value, "BigIntLiteralTypeAnnotation");
+
+ case 88:
+ this.next();
+ return this.finishNode(node, "VoidTypeAnnotation");
+
+ case 84:
+ this.next();
+ return this.finishNode(node, "NullLiteralTypeAnnotation");
+
+ case 78:
+ this.next();
+ return this.finishNode(node, "ThisTypeAnnotation");
+
+ case 55:
+ this.next();
+ return this.finishNode(node, "ExistsTypeAnnotation");
+
+ case 87:
+ return this.flowParseTypeofType();
+
+ default:
+ if (tokenIsKeyword(this.state.type)) {
+ const label = tokenLabelName(this.state.type);
+ this.next();
+ return super.createIdentifier(node, label);
+ } else if (tokenIsIdentifier(this.state.type)) {
+ if (this.isContextual(125)) {
+ return this.flowParseInterfaceType();
+ }
+
+ return this.flowIdentToTypeAnnotation(startPos, startLoc, node, this.parseIdentifier());
+ }
+
+ }
+
+ throw this.unexpected();
+ }
+
+ flowParsePostfixType() {
+ const startPos = this.state.start;
+ const startLoc = this.state.startLoc;
+ let type = this.flowParsePrimaryType();
+ let seenOptionalIndexedAccess = false;
+
+ while ((this.match(0) || this.match(18)) && !this.canInsertSemicolon()) {
+ const node = this.startNodeAt(startPos, startLoc);
+ const optional = this.eat(18);
+ seenOptionalIndexedAccess = seenOptionalIndexedAccess || optional;
+ this.expect(0);
+
+ if (!optional && this.match(3)) {
+ node.elementType = type;
+ this.next();
+ type = this.finishNode(node, "ArrayTypeAnnotation");
+ } else {
+ node.objectType = type;
+ node.indexType = this.flowParseType();
+ this.expect(3);
+
+ if (seenOptionalIndexedAccess) {
+ node.optional = optional;
+ type = this.finishNode(node, "OptionalIndexedAccessType");
+ } else {
+ type = this.finishNode(node, "IndexedAccessType");
+ }
+ }
+ }
+
+ return type;
+ }
+
+ flowParsePrefixType() {
+ const node = this.startNode();
+
+ if (this.eat(17)) {
+ node.typeAnnotation = this.flowParsePrefixType();
+ return this.finishNode(node, "NullableTypeAnnotation");
+ } else {
+ return this.flowParsePostfixType();
+ }
+ }
+
+ flowParseAnonFunctionWithoutParens() {
+ const param = this.flowParsePrefixType();
+
+ if (!this.state.noAnonFunctionType && this.eat(19)) {
+ const node = this.startNodeAt(param.start, param.loc.start);
+ node.params = [this.reinterpretTypeAsFunctionTypeParam(param)];
+ node.rest = null;
+ node.this = null;
+ node.returnType = this.flowParseType();
+ node.typeParameters = null;
+ return this.finishNode(node, "FunctionTypeAnnotation");
+ }
+
+ return param;
+ }
+
+ flowParseIntersectionType() {
+ const node = this.startNode();
+ this.eat(45);
+ const type = this.flowParseAnonFunctionWithoutParens();
+ node.types = [type];
+
+ while (this.eat(45)) {
+ node.types.push(this.flowParseAnonFunctionWithoutParens());
+ }
+
+ return node.types.length === 1 ? type : this.finishNode(node, "IntersectionTypeAnnotation");
+ }
+
+ flowParseUnionType() {
+ const node = this.startNode();
+ this.eat(43);
+ const type = this.flowParseIntersectionType();
+ node.types = [type];
+
+ while (this.eat(43)) {
+ node.types.push(this.flowParseIntersectionType());
+ }
+
+ return node.types.length === 1 ? type : this.finishNode(node, "UnionTypeAnnotation");
+ }
+
+ flowParseType() {
+ const oldInType = this.state.inType;
+ this.state.inType = true;
+ const type = this.flowParseUnionType();
+ this.state.inType = oldInType;
+ return type;
+ }
+
+ flowParseTypeOrImplicitInstantiation() {
+ if (this.state.type === 128 && this.state.value === "_") {
+ const startPos = this.state.start;
+ const startLoc = this.state.startLoc;
+ const node = this.parseIdentifier();
+ return this.flowParseGenericType(startPos, startLoc, node);
+ } else {
+ return this.flowParseType();
+ }
+ }
+
+ flowParseTypeAnnotation() {
+ const node = this.startNode();
+ node.typeAnnotation = this.flowParseTypeInitialiser();
+ return this.finishNode(node, "TypeAnnotation");
+ }
+
+ flowParseTypeAnnotatableIdentifier(allowPrimitiveOverride) {
+ const ident = allowPrimitiveOverride ? this.parseIdentifier() : this.flowParseRestrictedIdentifier();
+
+ if (this.match(14)) {
+ ident.typeAnnotation = this.flowParseTypeAnnotation();
+ this.resetEndLocation(ident);
+ }
+
+ return ident;
+ }
+
+ typeCastToParameter(node) {
+ node.expression.typeAnnotation = node.typeAnnotation;
+ this.resetEndLocation(node.expression, node.typeAnnotation.loc.end);
+ return node.expression;
+ }
+
+ flowParseVariance() {
+ let variance = null;
+
+ if (this.match(53)) {
+ variance = this.startNode();
+
+ if (this.state.value === "+") {
+ variance.kind = "plus";
+ } else {
+ variance.kind = "minus";
+ }
+
+ this.next();
+ this.finishNode(variance, "Variance");
+ }
+
+ return variance;
+ }
+
+ parseFunctionBody(node, allowExpressionBody, isMethod = false) {
+ if (allowExpressionBody) {
+ return this.forwardNoArrowParamsConversionAt(node, () => super.parseFunctionBody(node, true, isMethod));
+ }
+
+ return super.parseFunctionBody(node, false, isMethod);
+ }
+
+ parseFunctionBodyAndFinish(node, type, isMethod = false) {
+ if (this.match(14)) {
+ const typeNode = this.startNode();
+ [typeNode.typeAnnotation, node.predicate] = this.flowParseTypeAndPredicateInitialiser();
+ node.returnType = typeNode.typeAnnotation ? this.finishNode(typeNode, "TypeAnnotation") : null;
+ }
+
+ super.parseFunctionBodyAndFinish(node, type, isMethod);
+ }
+
+ parseStatement(context, topLevel) {
+ if (this.state.strict && this.isContextual(125)) {
+ const lookahead = this.lookahead();
+
+ if (tokenIsKeywordOrIdentifier(lookahead.type)) {
+ const node = this.startNode();
+ this.next();
+ return this.flowParseInterface(node);
+ }
+ } else if (this.shouldParseEnums() && this.isContextual(122)) {
+ const node = this.startNode();
+ this.next();
+ return this.flowParseEnumDeclaration(node);
+ }
+
+ const stmt = super.parseStatement(context, topLevel);
+
+ if (this.flowPragma === undefined && !this.isValidDirective(stmt)) {
+ this.flowPragma = null;
+ }
+
+ return stmt;
+ }
+
+ parseExpressionStatement(node, expr) {
+ if (expr.type === "Identifier") {
+ if (expr.name === "declare") {
+ if (this.match(80) || tokenIsIdentifier(this.state.type) || this.match(68) || this.match(74) || this.match(82)) {
+ return this.flowParseDeclare(node);
+ }
+ } else if (tokenIsIdentifier(this.state.type)) {
+ if (expr.name === "interface") {
+ return this.flowParseInterface(node);
+ } else if (expr.name === "type") {
+ return this.flowParseTypeAlias(node);
+ } else if (expr.name === "opaque") {
+ return this.flowParseOpaqueType(node, false);
+ }
+ }
+ }
+
+ return super.parseExpressionStatement(node, expr);
+ }
+
+ shouldParseExportDeclaration() {
+ const {
+ type
+ } = this.state;
+
+ if (tokenIsFlowInterfaceOrTypeOrOpaque(type) || this.shouldParseEnums() && type === 122) {
+ return !this.state.containsEsc;
+ }
+
+ return super.shouldParseExportDeclaration();
+ }
+
+ isExportDefaultSpecifier() {
+ const {
+ type
+ } = this.state;
+
+ if (tokenIsFlowInterfaceOrTypeOrOpaque(type) || this.shouldParseEnums() && type === 122) {
+ return this.state.containsEsc;
+ }
+
+ return super.isExportDefaultSpecifier();
+ }
+
+ parseExportDefaultExpression() {
+ if (this.shouldParseEnums() && this.isContextual(122)) {
+ const node = this.startNode();
+ this.next();
+ return this.flowParseEnumDeclaration(node);
+ }
+
+ return super.parseExportDefaultExpression();
+ }
+
+ parseConditional(expr, startPos, startLoc, refExpressionErrors) {
+ if (!this.match(17)) return expr;
+
+ if (this.state.maybeInArrowParameters) {
+ const nextCh = this.lookaheadCharCode();
+
+ if (nextCh === 44 || nextCh === 61 || nextCh === 58 || nextCh === 41) {
+ this.setOptionalParametersError(refExpressionErrors);
+ return expr;
+ }
+ }
+
+ this.expect(17);
+ const state = this.state.clone();
+ const originalNoArrowAt = this.state.noArrowAt;
+ const node = this.startNodeAt(startPos, startLoc);
+ let {
+ consequent,
+ failed
+ } = this.tryParseConditionalConsequent();
+ let [valid, invalid] = this.getArrowLikeExpressions(consequent);
+
+ if (failed || invalid.length > 0) {
+ const noArrowAt = [...originalNoArrowAt];
+
+ if (invalid.length > 0) {
+ this.state = state;
+ this.state.noArrowAt = noArrowAt;
+
+ for (let i = 0; i < invalid.length; i++) {
+ noArrowAt.push(invalid[i].start);
+ }
+
+ ({
+ consequent,
+ failed
+ } = this.tryParseConditionalConsequent());
+ [valid, invalid] = this.getArrowLikeExpressions(consequent);
+ }
+
+ if (failed && valid.length > 1) {
+ this.raise(FlowErrors.AmbiguousConditionalArrow, {
+ at: state.startLoc
+ });
+ }
+
+ if (failed && valid.length === 1) {
+ this.state = state;
+ noArrowAt.push(valid[0].start);
+ this.state.noArrowAt = noArrowAt;
+ ({
+ consequent,
+ failed
+ } = this.tryParseConditionalConsequent());
+ }
+ }
+
+ this.getArrowLikeExpressions(consequent, true);
+ this.state.noArrowAt = originalNoArrowAt;
+ this.expect(14);
+ node.test = expr;
+ node.consequent = consequent;
+ node.alternate = this.forwardNoArrowParamsConversionAt(node, () => this.parseMaybeAssign(undefined, undefined));
+ return this.finishNode(node, "ConditionalExpression");
+ }
+
+ tryParseConditionalConsequent() {
+ this.state.noArrowParamsConversionAt.push(this.state.start);
+ const consequent = this.parseMaybeAssignAllowIn();
+ const failed = !this.match(14);
+ this.state.noArrowParamsConversionAt.pop();
+ return {
+ consequent,
+ failed
+ };
+ }
+
+ getArrowLikeExpressions(node, disallowInvalid) {
+ const stack = [node];
+ const arrows = [];
+
+ while (stack.length !== 0) {
+ const node = stack.pop();
+
+ if (node.type === "ArrowFunctionExpression") {
+ if (node.typeParameters || !node.returnType) {
+ this.finishArrowValidation(node);
+ } else {
+ arrows.push(node);
+ }
+
+ stack.push(node.body);
+ } else if (node.type === "ConditionalExpression") {
+ stack.push(node.consequent);
+ stack.push(node.alternate);
+ }
+ }
+
+ if (disallowInvalid) {
+ arrows.forEach(node => this.finishArrowValidation(node));
+ return [arrows, []];
+ }
+
+ return partition(arrows, node => node.params.every(param => this.isAssignable(param, true)));
+ }
+
+ finishArrowValidation(node) {
+ var _node$extra;
+
+ this.toAssignableList(node.params, (_node$extra = node.extra) == null ? void 0 : _node$extra.trailingCommaLoc, false);
+ this.scope.enter(SCOPE_FUNCTION | SCOPE_ARROW);
+ super.checkParams(node, false, true);
+ this.scope.exit();
+ }
+
+ forwardNoArrowParamsConversionAt(node, parse) {
+ let result;
+
+ if (this.state.noArrowParamsConversionAt.indexOf(node.start) !== -1) {
+ this.state.noArrowParamsConversionAt.push(this.state.start);
+ result = parse();
+ this.state.noArrowParamsConversionAt.pop();
+ } else {
+ result = parse();
+ }
+
+ return result;
+ }
+
+ parseParenItem(node, startPos, startLoc) {
+ node = super.parseParenItem(node, startPos, startLoc);
+
+ if (this.eat(17)) {
+ node.optional = true;
+ this.resetEndLocation(node);
+ }
+
+ if (this.match(14)) {
+ const typeCastNode = this.startNodeAt(startPos, startLoc);
+ typeCastNode.expression = node;
+ typeCastNode.typeAnnotation = this.flowParseTypeAnnotation();
+ return this.finishNode(typeCastNode, "TypeCastExpression");
+ }
+
+ return node;
+ }
+
+ assertModuleNodeAllowed(node) {
+ if (node.type === "ImportDeclaration" && (node.importKind === "type" || node.importKind === "typeof") || node.type === "ExportNamedDeclaration" && node.exportKind === "type" || node.type === "ExportAllDeclaration" && node.exportKind === "type") {
+ return;
+ }
+
+ super.assertModuleNodeAllowed(node);
+ }
+
+ parseExport(node) {
+ const decl = super.parseExport(node);
+
+ if (decl.type === "ExportNamedDeclaration" || decl.type === "ExportAllDeclaration") {
+ decl.exportKind = decl.exportKind || "value";
+ }
+
+ return decl;
+ }
+
+ parseExportDeclaration(node) {
+ if (this.isContextual(126)) {
+ node.exportKind = "type";
+ const declarationNode = this.startNode();
+ this.next();
+
+ if (this.match(5)) {
+ node.specifiers = this.parseExportSpecifiers(true);
+ this.parseExportFrom(node);
+ return null;
+ } else {
+ return this.flowParseTypeAlias(declarationNode);
+ }
+ } else if (this.isContextual(127)) {
+ node.exportKind = "type";
+ const declarationNode = this.startNode();
+ this.next();
+ return this.flowParseOpaqueType(declarationNode, false);
+ } else if (this.isContextual(125)) {
+ node.exportKind = "type";
+ const declarationNode = this.startNode();
+ this.next();
+ return this.flowParseInterface(declarationNode);
+ } else if (this.shouldParseEnums() && this.isContextual(122)) {
+ node.exportKind = "value";
+ const declarationNode = this.startNode();
+ this.next();
+ return this.flowParseEnumDeclaration(declarationNode);
+ } else {
+ return super.parseExportDeclaration(node);
+ }
+ }
+
+ eatExportStar(node) {
+ if (super.eatExportStar(...arguments)) return true;
+
+ if (this.isContextual(126) && this.lookahead().type === 55) {
+ node.exportKind = "type";
+ this.next();
+ this.next();
+ return true;
+ }
+
+ return false;
+ }
+
+ maybeParseExportNamespaceSpecifier(node) {
+ const {
+ startLoc
+ } = this.state;
+ const hasNamespace = super.maybeParseExportNamespaceSpecifier(node);
+
+ if (hasNamespace && node.exportKind === "type") {
+ this.unexpected(startLoc);
+ }
+
+ return hasNamespace;
+ }
+
+ parseClassId(node, isStatement, optionalId) {
+ super.parseClassId(node, isStatement, optionalId);
+
+ if (this.match(47)) {
+ node.typeParameters = this.flowParseTypeParameterDeclaration();
+ }
+ }
+
+ parseClassMember(classBody, member, state) {
+ const {
+ startLoc
+ } = this.state;
+
+ if (this.isContextual(121)) {
+ if (this.parseClassMemberFromModifier(classBody, member)) {
+ return;
+ }
+
+ member.declare = true;
+ }
+
+ super.parseClassMember(classBody, member, state);
+
+ if (member.declare) {
+ if (member.type !== "ClassProperty" && member.type !== "ClassPrivateProperty" && member.type !== "PropertyDefinition") {
+ this.raise(FlowErrors.DeclareClassElement, {
+ at: startLoc
+ });
+ } else if (member.value) {
+ this.raise(FlowErrors.DeclareClassFieldInitializer, {
+ node: member.value
+ });
+ }
+ }
+ }
+
+ isIterator(word) {
+ return word === "iterator" || word === "asyncIterator";
+ }
+
+ readIterator() {
+ const word = super.readWord1();
+ const fullWord = "@@" + word;
+
+ if (!this.isIterator(word) || !this.state.inType) {
+ this.raise(ErrorMessages.InvalidIdentifier, {
+ at: this.state.curPosition()
+ }, fullWord);
+ }
+
+ this.finishToken(128, fullWord);
+ }
+
+ getTokenFromCode(code) {
+ const next = this.input.charCodeAt(this.state.pos + 1);
+
+ if (code === 123 && next === 124) {
+ return this.finishOp(6, 2);
+ } else if (this.state.inType && (code === 62 || code === 60)) {
+ return this.finishOp(code === 62 ? 48 : 47, 1);
+ } else if (this.state.inType && code === 63) {
+ if (next === 46) {
+ return this.finishOp(18, 2);
+ }
+
+ return this.finishOp(17, 1);
+ } else if (isIteratorStart(code, next, this.input.charCodeAt(this.state.pos + 2))) {
+ this.state.pos += 2;
+ return this.readIterator();
+ } else {
+ return super.getTokenFromCode(code);
+ }
+ }
+
+ isAssignable(node, isBinding) {
+ if (node.type === "TypeCastExpression") {
+ return this.isAssignable(node.expression, isBinding);
+ } else {
+ return super.isAssignable(node, isBinding);
+ }
+ }
+
+ toAssignable(node, isLHS = false) {
+ if (node.type === "TypeCastExpression") {
+ return super.toAssignable(this.typeCastToParameter(node), isLHS);
+ } else {
+ return super.toAssignable(node, isLHS);
+ }
+ }
+
+ toAssignableList(exprList, trailingCommaLoc, isLHS) {
+ for (let i = 0; i < exprList.length; i++) {
+ const expr = exprList[i];
+
+ if ((expr == null ? void 0 : expr.type) === "TypeCastExpression") {
+ exprList[i] = this.typeCastToParameter(expr);
+ }
+ }
+
+ return super.toAssignableList(exprList, trailingCommaLoc, isLHS);
+ }
+
+ toReferencedList(exprList, isParenthesizedExpr) {
+ for (let i = 0; i < exprList.length; i++) {
+ var _expr$extra;
+
+ const expr = exprList[i];
+
+ if (expr && expr.type === "TypeCastExpression" && !((_expr$extra = expr.extra) != null && _expr$extra.parenthesized) && (exprList.length > 1 || !isParenthesizedExpr)) {
+ this.raise(FlowErrors.TypeCastInPattern, {
+ node: expr.typeAnnotation
+ });
+ }
+ }
+
+ return exprList;
+ }
+
+ parseArrayLike(close, canBePattern, isTuple, refExpressionErrors) {
+ const node = super.parseArrayLike(close, canBePattern, isTuple, refExpressionErrors);
+
+ if (canBePattern && !this.state.maybeInArrowParameters) {
+ this.toReferencedList(node.elements);
+ }
+
+ return node;
+ }
+
+ checkLVal(expr, ...args) {
+ if (expr.type !== "TypeCastExpression") {
+ return super.checkLVal(expr, ...args);
+ }
+ }
+
+ parseClassProperty(node) {
+ if (this.match(14)) {
+ node.typeAnnotation = this.flowParseTypeAnnotation();
+ }
+
+ return super.parseClassProperty(node);
+ }
+
+ parseClassPrivateProperty(node) {
+ if (this.match(14)) {
+ node.typeAnnotation = this.flowParseTypeAnnotation();
+ }
+
+ return super.parseClassPrivateProperty(node);
+ }
+
+ isClassMethod() {
+ return this.match(47) || super.isClassMethod();
+ }
+
+ isClassProperty() {
+ return this.match(14) || super.isClassProperty();
+ }
+
+ isNonstaticConstructor(method) {
+ return !this.match(14) && super.isNonstaticConstructor(method);
+ }
+
+ pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) {
+ if (method.variance) {
+ this.unexpected(method.variance.loc.start);
+ }
+
+ delete method.variance;
+
+ if (this.match(47)) {
+ method.typeParameters = this.flowParseTypeParameterDeclaration();
+ }
+
+ super.pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper);
+
+ if (method.params && isConstructor) {
+ const params = method.params;
+
+ if (params.length > 0 && this.isThisParam(params[0])) {
+ this.raise(FlowErrors.ThisParamBannedInConstructor, {
+ node: method
+ });
+ }
+ } else if (method.type === "MethodDefinition" && isConstructor && method.value.params) {
+ const params = method.value.params;
+
+ if (params.length > 0 && this.isThisParam(params[0])) {
+ this.raise(FlowErrors.ThisParamBannedInConstructor, {
+ node: method
+ });
+ }
+ }
+ }
+
+ pushClassPrivateMethod(classBody, method, isGenerator, isAsync) {
+ if (method.variance) {
+ this.unexpected(method.variance.loc.start);
+ }
+
+ delete method.variance;
+
+ if (this.match(47)) {
+ method.typeParameters = this.flowParseTypeParameterDeclaration();
+ }
+
+ super.pushClassPrivateMethod(classBody, method, isGenerator, isAsync);
+ }
+
+ parseClassSuper(node) {
+ super.parseClassSuper(node);
+
+ if (node.superClass && this.match(47)) {
+ node.superTypeParameters = this.flowParseTypeParameterInstantiation();
+ }
+
+ if (this.isContextual(110)) {
+ this.next();
+ const implemented = node.implements = [];
+
+ do {
+ const node = this.startNode();
+ node.id = this.flowParseRestrictedIdentifier(true);
+
+ if (this.match(47)) {
+ node.typeParameters = this.flowParseTypeParameterInstantiation();
+ } else {
+ node.typeParameters = null;
+ }
+
+ implemented.push(this.finishNode(node, "ClassImplements"));
+ } while (this.eat(12));
+ }
+ }
+
+ checkGetterSetterParams(method) {
+ super.checkGetterSetterParams(method);
+ const params = this.getObjectOrClassMethodParams(method);
+
+ if (params.length > 0) {
+ const param = params[0];
+
+ if (this.isThisParam(param) && method.kind === "get") {
+ this.raise(FlowErrors.GetterMayNotHaveThisParam, {
+ node: param
+ });
+ } else if (this.isThisParam(param)) {
+ this.raise(FlowErrors.SetterMayNotHaveThisParam, {
+ node: param
+ });
+ }
+ }
+ }
+
+ parsePropertyNamePrefixOperator(node) {
+ node.variance = this.flowParseVariance();
+ }
+
+ parseObjPropValue(prop, startPos, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors) {
+ if (prop.variance) {
+ this.unexpected(prop.variance.loc.start);
+ }
+
+ delete prop.variance;
+ let typeParameters;
+
+ if (this.match(47) && !isAccessor) {
+ typeParameters = this.flowParseTypeParameterDeclaration();
+ if (!this.match(10)) this.unexpected();
+ }
+
+ super.parseObjPropValue(prop, startPos, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors);
+
+ if (typeParameters) {
+ (prop.value || prop).typeParameters = typeParameters;
+ }
+ }
+
+ parseAssignableListItemTypes(param) {
+ if (this.eat(17)) {
+ if (param.type !== "Identifier") {
+ this.raise(FlowErrors.PatternIsOptional, {
+ node: param
+ });
+ }
+
+ if (this.isThisParam(param)) {
+ this.raise(FlowErrors.ThisParamMayNotBeOptional, {
+ node: param
+ });
+ }
+
+ param.optional = true;
+ }
+
+ if (this.match(14)) {
+ param.typeAnnotation = this.flowParseTypeAnnotation();
+ } else if (this.isThisParam(param)) {
+ this.raise(FlowErrors.ThisParamAnnotationRequired, {
+ node: param
+ });
+ }
+
+ if (this.match(29) && this.isThisParam(param)) {
+ this.raise(FlowErrors.ThisParamNoDefault, {
+ node: param
+ });
+ }
+
+ this.resetEndLocation(param);
+ return param;
+ }
+
+ parseMaybeDefault(startPos, startLoc, left) {
+ const node = super.parseMaybeDefault(startPos, startLoc, left);
+
+ if (node.type === "AssignmentPattern" && node.typeAnnotation && node.right.start < node.typeAnnotation.start) {
+ this.raise(FlowErrors.TypeBeforeInitializer, {
+ node: node.typeAnnotation
+ });
+ }
+
+ return node;
+ }
+
+ shouldParseDefaultImport(node) {
+ if (!hasTypeImportKind(node)) {
+ return super.shouldParseDefaultImport(node);
+ }
+
+ return isMaybeDefaultImport(this.state.type);
+ }
+
+ parseImportSpecifierLocal(node, specifier, type, contextDescription) {
+ specifier.local = hasTypeImportKind(node) ? this.flowParseRestrictedIdentifier(true, true) : this.parseIdentifier();
+ this.checkLVal(specifier.local, contextDescription, BIND_LEXICAL);
+ node.specifiers.push(this.finishNode(specifier, type));
+ }
+
+ maybeParseDefaultImportSpecifier(node) {
+ node.importKind = "value";
+ let kind = null;
+
+ if (this.match(87)) {
+ kind = "typeof";
+ } else if (this.isContextual(126)) {
+ kind = "type";
+ }
+
+ if (kind) {
+ const lh = this.lookahead();
+ const {
+ type
+ } = lh;
+
+ if (kind === "type" && type === 55) {
+ this.unexpected(null, lh.type);
+ }
+
+ if (isMaybeDefaultImport(type) || type === 5 || type === 55) {
+ this.next();
+ node.importKind = kind;
+ }
+ }
+
+ return super.maybeParseDefaultImportSpecifier(node);
+ }
+
+ parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly) {
+ const firstIdent = specifier.imported;
+ let specifierTypeKind = null;
+
+ if (firstIdent.type === "Identifier") {
+ if (firstIdent.name === "type") {
+ specifierTypeKind = "type";
+ } else if (firstIdent.name === "typeof") {
+ specifierTypeKind = "typeof";
+ }
+ }
+
+ let isBinding = false;
+
+ if (this.isContextual(93) && !this.isLookaheadContextual("as")) {
+ const as_ident = this.parseIdentifier(true);
+
+ if (specifierTypeKind !== null && !tokenIsKeywordOrIdentifier(this.state.type)) {
+ specifier.imported = as_ident;
+ specifier.importKind = specifierTypeKind;
+ specifier.local = cloneIdentifier(as_ident);
+ } else {
+ specifier.imported = firstIdent;
+ specifier.importKind = null;
+ specifier.local = this.parseIdentifier();
+ }
+ } else {
+ if (specifierTypeKind !== null && tokenIsKeywordOrIdentifier(this.state.type)) {
+ specifier.imported = this.parseIdentifier(true);
+ specifier.importKind = specifierTypeKind;
+ } else {
+ if (importedIsString) {
+ throw this.raise(ErrorMessages.ImportBindingIsString, {
+ node: specifier
+ }, firstIdent.value);
+ }
+
+ specifier.imported = firstIdent;
+ specifier.importKind = null;
+ }
+
+ if (this.eatContextual(93)) {
+ specifier.local = this.parseIdentifier();
+ } else {
+ isBinding = true;
+ specifier.local = cloneIdentifier(specifier.imported);
+ }
+ }
+
+ const specifierIsTypeImport = hasTypeImportKind(specifier);
+
+ if (isInTypeOnlyImport && specifierIsTypeImport) {
+ this.raise(FlowErrors.ImportTypeShorthandOnlyInPureImport, {
+ node: specifier
+ });
+ }
+
+ if (isInTypeOnlyImport || specifierIsTypeImport) {
+ this.checkReservedType(specifier.local.name, specifier.local.loc.start, true);
+ }
+
+ if (isBinding && !isInTypeOnlyImport && !specifierIsTypeImport) {
+ this.checkReservedWord(specifier.local.name, specifier.loc.start, true, true);
+ }
+
+ this.checkLVal(specifier.local, "import specifier", BIND_LEXICAL);
+ return this.finishNode(specifier, "ImportSpecifier");
+ }
+
+ parseBindingAtom() {
+ switch (this.state.type) {
+ case 78:
+ return this.parseIdentifier(true);
+
+ default:
+ return super.parseBindingAtom();
+ }
+ }
+
+ parseFunctionParams(node, allowModifiers) {
+ const kind = node.kind;
+
+ if (kind !== "get" && kind !== "set" && this.match(47)) {
+ node.typeParameters = this.flowParseTypeParameterDeclaration();
+ }
+
+ super.parseFunctionParams(node, allowModifiers);
+ }
+
+ parseVarId(decl, kind) {
+ super.parseVarId(decl, kind);
+
+ if (this.match(14)) {
+ decl.id.typeAnnotation = this.flowParseTypeAnnotation();
+ this.resetEndLocation(decl.id);
+ }
+ }
+
+ parseAsyncArrowFromCallExpression(node, call) {
+ if (this.match(14)) {
+ const oldNoAnonFunctionType = this.state.noAnonFunctionType;
+ this.state.noAnonFunctionType = true;
+ node.returnType = this.flowParseTypeAnnotation();
+ this.state.noAnonFunctionType = oldNoAnonFunctionType;
+ }
+
+ return super.parseAsyncArrowFromCallExpression(node, call);
+ }
+
+ shouldParseAsyncArrow() {
+ return this.match(14) || super.shouldParseAsyncArrow();
+ }
+
+ parseMaybeAssign(refExpressionErrors, afterLeftParse) {
+ var _jsx;
+
+ let state = null;
+ let jsx;
+
+ if (this.hasPlugin("jsx") && (this.match(138) || this.match(47))) {
+ state = this.state.clone();
+ jsx = this.tryParse(() => super.parseMaybeAssign(refExpressionErrors, afterLeftParse), state);
+ if (!jsx.error) return jsx.node;
+ const {
+ context
+ } = this.state;
+ const currentContext = context[context.length - 1];
+
+ if (currentContext === types.j_oTag || currentContext === types.j_expr) {
+ context.pop();
+ }
+ }
+
+ if ((_jsx = jsx) != null && _jsx.error || this.match(47)) {
+ var _jsx2, _jsx3;
+
+ state = state || this.state.clone();
+ let typeParameters;
+ const arrow = this.tryParse(abort => {
+ var _arrowExpression$extr;
+
+ typeParameters = this.flowParseTypeParameterDeclaration();
+ const arrowExpression = this.forwardNoArrowParamsConversionAt(typeParameters, () => {
+ const result = super.parseMaybeAssign(refExpressionErrors, afterLeftParse);
+ this.resetStartLocationFromNode(result, typeParameters);
+ return result;
+ });
+ if ((_arrowExpression$extr = arrowExpression.extra) != null && _arrowExpression$extr.parenthesized) abort();
+ const expr = this.maybeUnwrapTypeCastExpression(arrowExpression);
+ if (expr.type !== "ArrowFunctionExpression") abort();
+ expr.typeParameters = typeParameters;
+ this.resetStartLocationFromNode(expr, typeParameters);
+ return arrowExpression;
+ }, state);
+ let arrowExpression = null;
+
+ if (arrow.node && this.maybeUnwrapTypeCastExpression(arrow.node).type === "ArrowFunctionExpression") {
+ if (!arrow.error && !arrow.aborted) {
+ if (arrow.node.async) {
+ this.raise(FlowErrors.UnexpectedTypeParameterBeforeAsyncArrowFunction, {
+ node: typeParameters
+ });
+ }
+
+ return arrow.node;
+ }
+
+ arrowExpression = arrow.node;
+ }
+
+ if ((_jsx2 = jsx) != null && _jsx2.node) {
+ this.state = jsx.failState;
+ return jsx.node;
+ }
+
+ if (arrowExpression) {
+ this.state = arrow.failState;
+ return arrowExpression;
+ }
+
+ if ((_jsx3 = jsx) != null && _jsx3.thrown) throw jsx.error;
+ if (arrow.thrown) throw arrow.error;
+ throw this.raise(FlowErrors.UnexpectedTokenAfterTypeParameter, {
+ node: typeParameters
+ });
+ }
+
+ return super.parseMaybeAssign(refExpressionErrors, afterLeftParse);
+ }
+
+ parseArrow(node) {
+ if (this.match(14)) {
+ const result = this.tryParse(() => {
+ const oldNoAnonFunctionType = this.state.noAnonFunctionType;
+ this.state.noAnonFunctionType = true;
+ const typeNode = this.startNode();
+ [typeNode.typeAnnotation, node.predicate] = this.flowParseTypeAndPredicateInitialiser();
+ this.state.noAnonFunctionType = oldNoAnonFunctionType;
+ if (this.canInsertSemicolon()) this.unexpected();
+ if (!this.match(19)) this.unexpected();
+ return typeNode;
+ });
+ if (result.thrown) return null;
+ if (result.error) this.state = result.failState;
+ node.returnType = result.node.typeAnnotation ? this.finishNode(result.node, "TypeAnnotation") : null;
+ }
+
+ return super.parseArrow(node);
+ }
+
+ shouldParseArrow(params) {
+ return this.match(14) || super.shouldParseArrow(params);
+ }
+
+ setArrowFunctionParameters(node, params) {
+ if (this.state.noArrowParamsConversionAt.indexOf(node.start) !== -1) {
+ node.params = params;
+ } else {
+ super.setArrowFunctionParameters(node, params);
+ }
+ }
+
+ checkParams(node, allowDuplicates, isArrowFunction) {
+ if (isArrowFunction && this.state.noArrowParamsConversionAt.indexOf(node.start) !== -1) {
+ return;
+ }
+
+ for (let i = 0; i < node.params.length; i++) {
+ if (this.isThisParam(node.params[i]) && i > 0) {
+ this.raise(FlowErrors.ThisParamMustBeFirst, {
+ node: node.params[i]
+ });
+ }
+ }
+
+ return super.checkParams(...arguments);
+ }
+
+ parseParenAndDistinguishExpression(canBeArrow) {
+ return super.parseParenAndDistinguishExpression(canBeArrow && this.state.noArrowAt.indexOf(this.state.start) === -1);
+ }
+
+ parseSubscripts(base, startPos, startLoc, noCalls) {
+ if (base.type === "Identifier" && base.name === "async" && this.state.noArrowAt.indexOf(startPos) !== -1) {
+ this.next();
+ const node = this.startNodeAt(startPos, startLoc);
+ node.callee = base;
+ node.arguments = this.parseCallExpressionArguments(11, false);
+ base = this.finishNode(node, "CallExpression");
+ } else if (base.type === "Identifier" && base.name === "async" && this.match(47)) {
+ const state = this.state.clone();
+ const arrow = this.tryParse(abort => this.parseAsyncArrowWithTypeParameters(startPos, startLoc) || abort(), state);
+ if (!arrow.error && !arrow.aborted) return arrow.node;
+ const result = this.tryParse(() => super.parseSubscripts(base, startPos, startLoc, noCalls), state);
+ if (result.node && !result.error) return result.node;
+
+ if (arrow.node) {
+ this.state = arrow.failState;
+ return arrow.node;
+ }
+
+ if (result.node) {
+ this.state = result.failState;
+ return result.node;
+ }
+
+ throw arrow.error || result.error;
+ }
+
+ return super.parseSubscripts(base, startPos, startLoc, noCalls);
+ }
+
+ parseSubscript(base, startPos, startLoc, noCalls, subscriptState) {
+ if (this.match(18) && this.isLookaheadToken_lt()) {
+ subscriptState.optionalChainMember = true;
+
+ if (noCalls) {
+ subscriptState.stop = true;
+ return base;
+ }
+
+ this.next();
+ const node = this.startNodeAt(startPos, startLoc);
+ node.callee = base;
+ node.typeArguments = this.flowParseTypeParameterInstantiation();
+ this.expect(10);
+ node.arguments = this.parseCallExpressionArguments(11, false);
+ node.optional = true;
+ return this.finishCallExpression(node, true);
+ } else if (!noCalls && this.shouldParseTypes() && this.match(47)) {
+ const node = this.startNodeAt(startPos, startLoc);
+ node.callee = base;
+ const result = this.tryParse(() => {
+ node.typeArguments = this.flowParseTypeParameterInstantiationCallOrNew();
+ this.expect(10);
+ node.arguments = this.parseCallExpressionArguments(11, false);
+ if (subscriptState.optionalChainMember) node.optional = false;
+ return this.finishCallExpression(node, subscriptState.optionalChainMember);
+ });
+
+ if (result.node) {
+ if (result.error) this.state = result.failState;
+ return result.node;
+ }
+ }
+
+ return super.parseSubscript(base, startPos, startLoc, noCalls, subscriptState);
+ }
+
+ parseNewArguments(node) {
+ let targs = null;
+
+ if (this.shouldParseTypes() && this.match(47)) {
+ targs = this.tryParse(() => this.flowParseTypeParameterInstantiationCallOrNew()).node;
+ }
+
+ node.typeArguments = targs;
+ super.parseNewArguments(node);
+ }
+
+ parseAsyncArrowWithTypeParameters(startPos, startLoc) {
+ const node = this.startNodeAt(startPos, startLoc);
+ this.parseFunctionParams(node);
+ if (!this.parseArrow(node)) return;
+ return this.parseArrowExpression(node, undefined, true);
+ }
+
+ readToken_mult_modulo(code) {
+ const next = this.input.charCodeAt(this.state.pos + 1);
+
+ if (code === 42 && next === 47 && this.state.hasFlowComment) {
+ this.state.hasFlowComment = false;
+ this.state.pos += 2;
+ this.nextToken();
+ return;
+ }
+
+ super.readToken_mult_modulo(code);
+ }
+
+ readToken_pipe_amp(code) {
+ const next = this.input.charCodeAt(this.state.pos + 1);
+
+ if (code === 124 && next === 125) {
+ this.finishOp(9, 2);
+ return;
+ }
+
+ super.readToken_pipe_amp(code);
+ }
+
+ parseTopLevel(file, program) {
+ const fileNode = super.parseTopLevel(file, program);
+
+ if (this.state.hasFlowComment) {
+ this.raise(FlowErrors.UnterminatedFlowComment, {
+ at: this.state.curPosition()
+ });
+ }
+
+ return fileNode;
+ }
+
+ skipBlockComment() {
+ if (this.hasPlugin("flowComments") && this.skipFlowComment()) {
+ if (this.state.hasFlowComment) {
+ throw this.raise(FlowErrors.NestedFlowComment, {
+ at: this.state.startLoc
+ });
+ }
+
+ this.hasFlowCommentCompletion();
+ this.state.pos += this.skipFlowComment();
+ this.state.hasFlowComment = true;
+ return;
+ }
+
+ if (this.state.hasFlowComment) {
+ const end = this.input.indexOf("*-/", this.state.pos + 2);
+
+ if (end === -1) {
+ throw this.raise(ErrorMessages.UnterminatedComment, {
+ at: this.state.curPosition()
+ });
+ }
+
+ this.state.pos = end + 2 + 3;
+ return;
+ }
+
+ return super.skipBlockComment();
+ }
+
+ skipFlowComment() {
+ const {
+ pos
+ } = this.state;
+ let shiftToFirstNonWhiteSpace = 2;
+
+ while ([32, 9].includes(this.input.charCodeAt(pos + shiftToFirstNonWhiteSpace))) {
+ shiftToFirstNonWhiteSpace++;
+ }
+
+ const ch2 = this.input.charCodeAt(shiftToFirstNonWhiteSpace + pos);
+ const ch3 = this.input.charCodeAt(shiftToFirstNonWhiteSpace + pos + 1);
+
+ if (ch2 === 58 && ch3 === 58) {
+ return shiftToFirstNonWhiteSpace + 2;
+ }
+
+ if (this.input.slice(shiftToFirstNonWhiteSpace + pos, shiftToFirstNonWhiteSpace + pos + 12) === "flow-include") {
+ return shiftToFirstNonWhiteSpace + 12;
+ }
+
+ if (ch2 === 58 && ch3 !== 58) {
+ return shiftToFirstNonWhiteSpace;
+ }
+
+ return false;
+ }
+
+ hasFlowCommentCompletion() {
+ const end = this.input.indexOf("*/", this.state.pos);
+
+ if (end === -1) {
+ throw this.raise(ErrorMessages.UnterminatedComment, {
+ at: this.state.curPosition()
+ });
+ }
+ }
+
+ flowEnumErrorBooleanMemberNotInitialized(loc, {
+ enumName,
+ memberName
+ }) {
+ this.raise(FlowErrors.EnumBooleanMemberNotInitialized, {
+ at: loc
+ }, memberName, enumName);
+ }
+
+ flowEnumErrorInvalidExplicitType(loc, {
+ enumName,
+ suppliedType
+ }) {
+ return this.raise(suppliedType === null ? FlowErrors.EnumInvalidExplicitTypeUnknownSupplied : FlowErrors.EnumInvalidExplicitType, {
+ at: loc
+ }, enumName, suppliedType);
+ }
+
+ flowEnumErrorInvalidMemberInitializer(loc, {
+ enumName,
+ explicitType,
+ memberName
+ }) {
+ return this.raise(explicitType === "boolean" || explicitType === "number" || explicitType === "string" ? FlowErrors.EnumInvalidMemberInitializerPrimaryType : explicitType === "symbol" ? FlowErrors.EnumInvalidMemberInitializerSymbolType : FlowErrors.EnumInvalidMemberInitializerUnknownType, {
+ at: loc
+ }, enumName, memberName, explicitType);
+ }
+
+ flowEnumErrorNumberMemberNotInitialized(loc, {
+ enumName,
+ memberName
+ }) {
+ this.raise(FlowErrors.EnumNumberMemberNotInitialized, {
+ at: loc
+ }, enumName, memberName);
+ }
+
+ flowEnumErrorStringMemberInconsistentlyInitailized(node, {
+ enumName
+ }) {
+ this.raise(FlowErrors.EnumStringMemberInconsistentlyInitailized, {
+ node
+ }, enumName);
+ }
+
+ flowEnumMemberInit() {
+ const startLoc = this.state.startLoc;
+
+ const endOfInit = () => this.match(12) || this.match(8);
+
+ switch (this.state.type) {
+ case 130:
+ {
+ const literal = this.parseNumericLiteral(this.state.value);
+
+ if (endOfInit()) {
+ return {
+ type: "number",
+ loc: literal.loc.start,
+ value: literal
+ };
+ }
+
+ return {
+ type: "invalid",
+ loc: startLoc
+ };
+ }
+
+ case 129:
+ {
+ const literal = this.parseStringLiteral(this.state.value);
+
+ if (endOfInit()) {
+ return {
+ type: "string",
+ loc: literal.loc.start,
+ value: literal
+ };
+ }
+
+ return {
+ type: "invalid",
+ loc: startLoc
+ };
+ }
+
+ case 85:
+ case 86:
+ {
+ const literal = this.parseBooleanLiteral(this.match(85));
+
+ if (endOfInit()) {
+ return {
+ type: "boolean",
+ loc: literal.loc.start,
+ value: literal
+ };
+ }
+
+ return {
+ type: "invalid",
+ loc: startLoc
+ };
+ }
+
+ default:
+ return {
+ type: "invalid",
+ loc: startLoc
+ };
+ }
+ }
+
+ flowEnumMemberRaw() {
+ const loc = this.state.startLoc;
+ const id = this.parseIdentifier(true);
+ const init = this.eat(29) ? this.flowEnumMemberInit() : {
+ type: "none",
+ loc
+ };
+ return {
+ id,
+ init
+ };
+ }
+
+ flowEnumCheckExplicitTypeMismatch(loc, context, expectedType) {
+ const {
+ explicitType
+ } = context;
+
+ if (explicitType === null) {
+ return;
+ }
+
+ if (explicitType !== expectedType) {
+ this.flowEnumErrorInvalidMemberInitializer(loc, context);
+ }
+ }
+
+ flowEnumMembers({
+ enumName,
+ explicitType
+ }) {
+ const seenNames = new Set();
+ const members = {
+ booleanMembers: [],
+ numberMembers: [],
+ stringMembers: [],
+ defaultedMembers: []
+ };
+ let hasUnknownMembers = false;
+
+ while (!this.match(8)) {
+ if (this.eat(21)) {
+ hasUnknownMembers = true;
+ break;
+ }
+
+ const memberNode = this.startNode();
+ const {
+ id,
+ init
+ } = this.flowEnumMemberRaw();
+ const memberName = id.name;
+
+ if (memberName === "") {
+ continue;
+ }
+
+ if (/^[a-z]/.test(memberName)) {
+ this.raise(FlowErrors.EnumInvalidMemberName, {
+ node: id
+ }, memberName, memberName[0].toUpperCase() + memberName.slice(1), enumName);
+ }
+
+ if (seenNames.has(memberName)) {
+ this.raise(FlowErrors.EnumDuplicateMemberName, {
+ node: id
+ }, memberName, enumName);
+ }
+
+ seenNames.add(memberName);
+ const context = {
+ enumName,
+ explicitType,
+ memberName
+ };
+ memberNode.id = id;
+
+ switch (init.type) {
+ case "boolean":
+ {
+ this.flowEnumCheckExplicitTypeMismatch(init.loc, context, "boolean");
+ memberNode.init = init.value;
+ members.booleanMembers.push(this.finishNode(memberNode, "EnumBooleanMember"));
+ break;
+ }
+
+ case "number":
+ {
+ this.flowEnumCheckExplicitTypeMismatch(init.loc, context, "number");
+ memberNode.init = init.value;
+ members.numberMembers.push(this.finishNode(memberNode, "EnumNumberMember"));
+ break;
+ }
+
+ case "string":
+ {
+ this.flowEnumCheckExplicitTypeMismatch(init.loc, context, "string");
+ memberNode.init = init.value;
+ members.stringMembers.push(this.finishNode(memberNode, "EnumStringMember"));
+ break;
+ }
+
+ case "invalid":
+ {
+ throw this.flowEnumErrorInvalidMemberInitializer(init.loc, context);
+ }
+
+ case "none":
+ {
+ switch (explicitType) {
+ case "boolean":
+ this.flowEnumErrorBooleanMemberNotInitialized(init.loc, context);
+ break;
+
+ case "number":
+ this.flowEnumErrorNumberMemberNotInitialized(init.loc, context);
+ break;
+
+ default:
+ members.defaultedMembers.push(this.finishNode(memberNode, "EnumDefaultedMember"));
+ }
+ }
+ }
+
+ if (!this.match(8)) {
+ this.expect(12);
+ }
+ }
+
+ return {
+ members,
+ hasUnknownMembers
+ };
+ }
+
+ flowEnumStringMembers(initializedMembers, defaultedMembers, {
+ enumName
+ }) {
+ if (initializedMembers.length === 0) {
+ return defaultedMembers;
+ } else if (defaultedMembers.length === 0) {
+ return initializedMembers;
+ } else if (defaultedMembers.length > initializedMembers.length) {
+ for (const member of initializedMembers) {
+ this.flowEnumErrorStringMemberInconsistentlyInitailized(member, {
+ enumName
+ });
+ }
+
+ return defaultedMembers;
+ } else {
+ for (const member of defaultedMembers) {
+ this.flowEnumErrorStringMemberInconsistentlyInitailized(member, {
+ enumName
+ });
+ }
+
+ return initializedMembers;
+ }
+ }
+
+ flowEnumParseExplicitType({
+ enumName
+ }) {
+ if (this.eatContextual(101)) {
+ if (!tokenIsIdentifier(this.state.type)) {
+ throw this.flowEnumErrorInvalidExplicitType(this.state.startLoc, {
+ enumName,
+ suppliedType: null
+ });
+ }
+
+ const {
+ value
+ } = this.state;
+ this.next();
+
+ if (value !== "boolean" && value !== "number" && value !== "string" && value !== "symbol") {
+ this.flowEnumErrorInvalidExplicitType(this.state.startLoc, {
+ enumName,
+ suppliedType: value
+ });
+ }
+
+ return value;
+ }
+
+ return null;
+ }
+
+ flowEnumBody(node, id) {
+ const enumName = id.name;
+ const nameLoc = id.loc.start;
+ const explicitType = this.flowEnumParseExplicitType({
+ enumName
+ });
+ this.expect(5);
+ const {
+ members,
+ hasUnknownMembers
+ } = this.flowEnumMembers({
+ enumName,
+ explicitType
+ });
+ node.hasUnknownMembers = hasUnknownMembers;
+
+ switch (explicitType) {
+ case "boolean":
+ node.explicitType = true;
+ node.members = members.booleanMembers;
+ this.expect(8);
+ return this.finishNode(node, "EnumBooleanBody");
+
+ case "number":
+ node.explicitType = true;
+ node.members = members.numberMembers;
+ this.expect(8);
+ return this.finishNode(node, "EnumNumberBody");
+
+ case "string":
+ node.explicitType = true;
+ node.members = this.flowEnumStringMembers(members.stringMembers, members.defaultedMembers, {
+ enumName
+ });
+ this.expect(8);
+ return this.finishNode(node, "EnumStringBody");
+
+ case "symbol":
+ node.members = members.defaultedMembers;
+ this.expect(8);
+ return this.finishNode(node, "EnumSymbolBody");
+
+ default:
+ {
+ const empty = () => {
+ node.members = [];
+ this.expect(8);
+ return this.finishNode(node, "EnumStringBody");
+ };
+
+ node.explicitType = false;
+ const boolsLen = members.booleanMembers.length;
+ const numsLen = members.numberMembers.length;
+ const strsLen = members.stringMembers.length;
+ const defaultedLen = members.defaultedMembers.length;
+
+ if (!boolsLen && !numsLen && !strsLen && !defaultedLen) {
+ return empty();
+ } else if (!boolsLen && !numsLen) {
+ node.members = this.flowEnumStringMembers(members.stringMembers, members.defaultedMembers, {
+ enumName
+ });
+ this.expect(8);
+ return this.finishNode(node, "EnumStringBody");
+ } else if (!numsLen && !strsLen && boolsLen >= defaultedLen) {
+ for (const member of members.defaultedMembers) {
+ this.flowEnumErrorBooleanMemberNotInitialized(member.loc.start, {
+ enumName,
+ memberName: member.id.name
+ });
+ }
+
+ node.members = members.booleanMembers;
+ this.expect(8);
+ return this.finishNode(node, "EnumBooleanBody");
+ } else if (!boolsLen && !strsLen && numsLen >= defaultedLen) {
+ for (const member of members.defaultedMembers) {
+ this.flowEnumErrorNumberMemberNotInitialized(member.loc.start, {
+ enumName,
+ memberName: member.id.name
+ });
+ }
+
+ node.members = members.numberMembers;
+ this.expect(8);
+ return this.finishNode(node, "EnumNumberBody");
+ } else {
+ this.raise(FlowErrors.EnumInconsistentMemberValues, {
+ at: nameLoc
+ }, enumName);
+ return empty();
+ }
+ }
+ }
+ }
+
+ flowParseEnumDeclaration(node) {
+ const id = this.parseIdentifier();
+ node.id = id;
+ node.body = this.flowEnumBody(this.startNode(), id);
+ return this.finishNode(node, "EnumDeclaration");
+ }
+
+ isLookaheadToken_lt() {
+ const next = this.nextTokenStart();
+
+ if (this.input.charCodeAt(next) === 60) {
+ const afterNext = this.input.charCodeAt(next + 1);
+ return afterNext !== 60 && afterNext !== 61;
+ }
+
+ return false;
+ }
+
+ maybeUnwrapTypeCastExpression(node) {
+ return node.type === "TypeCastExpression" ? node.expression : node;
+ }
+
+});
+
+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"
+};
+
+const HEX_NUMBER = /^[\da-fA-F]+$/;
+const DECIMAL_NUMBER = /^\d+$/;
+const JsxErrors = makeErrorTemplates({
+ AttributeIsEmpty: "JSX attributes must only be assigned a non-empty expression.",
+ MissingClosingTagElement: "Expected corresponding JSX closing tag for <%0>.",
+ MissingClosingTagFragment: "Expected corresponding JSX closing tag for <>.",
+ UnexpectedSequenceExpression: "Sequence expressions cannot be directly nested inside JSX. Did you mean to wrap it in parentheses (...)?",
+ 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 <>...?"
+}, ErrorCodes.SyntaxError, "jsx");
+
+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 jsx = (superClass => class extends superClass {
+ jsxReadToken() {
+ let out = "";
+ let chunkStart = this.state.pos;
+
+ for (;;) {
+ if (this.state.pos >= this.length) {
+ throw this.raise(JsxErrors.UnterminatedJsxContent, {
+ at: this.state.startLoc
+ });
+ }
+
+ 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.canStartJSXElement) {
+ ++this.state.pos;
+ return this.finishToken(138);
+ }
+
+ return super.getTokenFromCode(ch);
+ }
+
+ out += this.input.slice(chunkStart, this.state.pos);
+ return this.finishToken(137, out);
+
+ case 38:
+ out += this.input.slice(chunkStart, this.state.pos);
+ out += this.jsxReadEntity();
+ chunkStart = this.state.pos;
+ break;
+
+ case 62:
+ case 125:
+
+ default:
+ if (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(ErrorMessages.UnterminatedString, {
+ at: this.state.startLoc
+ });
+ }
+
+ 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 (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(129, 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 = entities[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 (isIdentifierChar(ch) || ch === 45);
+
+ return this.finishToken(136, this.input.slice(start, this.state.pos));
+ }
+
+ jsxParseIdentifier() {
+ const node = this.startNode();
+
+ if (this.match(136)) {
+ node.name = this.state.value;
+ } else if (tokenIsKeyword(this.state.type)) {
+ node.name = tokenLabelName(this.state.type);
+ } 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(14)) 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(16)) {
+ 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 5:
+ node = this.startNode();
+ this.setContext(types.brace);
+ this.next();
+ node = this.jsxParseExpressionContainer(node, types.j_oTag);
+
+ if (node.expression.type === "JSXEmptyExpression") {
+ this.raise(JsxErrors.AttributeIsEmpty, {
+ node
+ });
+ }
+
+ return node;
+
+ case 138:
+ case 129:
+ return this.parseExprAtom();
+
+ default:
+ throw this.raise(JsxErrors.UnsupportedJsxValue, {
+ at: this.state.startLoc
+ });
+ }
+ }
+
+ jsxParseEmptyExpression() {
+ const node = this.startNodeAt(this.state.lastTokEndLoc.index, this.state.lastTokEndLoc);
+ return this.finishNodeAt(node, "JSXEmptyExpression", this.state.startLoc);
+ }
+
+ jsxParseSpreadChild(node) {
+ this.next();
+ node.expression = this.parseExpression();
+ this.setContext(types.j_oTag);
+ this.expect(8);
+ return this.finishNode(node, "JSXSpreadChild");
+ }
+
+ jsxParseExpressionContainer(node, previousContext) {
+ if (this.match(8)) {
+ node.expression = this.jsxParseEmptyExpression();
+ } else {
+ const expression = this.parseExpression();
+ node.expression = expression;
+ }
+
+ this.setContext(previousContext);
+ this.expect(8);
+ return this.finishNode(node, "JSXExpressionContainer");
+ }
+
+ jsxParseAttribute() {
+ const node = this.startNode();
+
+ if (this.match(5)) {
+ this.setContext(types.brace);
+ this.next();
+ this.expect(21);
+ node.argument = this.parseMaybeAssignAllowIn();
+ this.setContext(types.j_oTag);
+ this.expect(8);
+ return this.finishNode(node, "JSXSpreadAttribute");
+ }
+
+ node.name = this.jsxParseNamespacedName();
+ node.value = this.eat(29) ? this.jsxParseAttributeValue() : null;
+ return this.finishNode(node, "JSXAttribute");
+ }
+
+ jsxParseOpeningElementAt(startPos, startLoc) {
+ const node = this.startNodeAt(startPos, startLoc);
+
+ if (this.match(139)) {
+ this.expect(139);
+ return this.finishNode(node, "JSXOpeningFragment");
+ }
+
+ node.name = this.jsxParseElementName();
+ return this.jsxParseOpeningElementAfterName(node);
+ }
+
+ jsxParseOpeningElementAfterName(node) {
+ const attributes = [];
+
+ while (!this.match(56) && !this.match(139)) {
+ attributes.push(this.jsxParseAttribute());
+ }
+
+ node.attributes = attributes;
+ node.selfClosing = this.eat(56);
+ this.expect(139);
+ return this.finishNode(node, "JSXOpeningElement");
+ }
+
+ jsxParseClosingElementAt(startPos, startLoc) {
+ const node = this.startNodeAt(startPos, startLoc);
+
+ if (this.match(139)) {
+ this.expect(139);
+ return this.finishNode(node, "JSXClosingFragment");
+ }
+
+ node.name = this.jsxParseElementName();
+ this.expect(139);
+ 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 138:
+ startPos = this.state.start;
+ startLoc = this.state.startLoc;
+ this.next();
+
+ if (this.eat(56)) {
+ closingElement = this.jsxParseClosingElementAt(startPos, startLoc);
+ break contents;
+ }
+
+ children.push(this.jsxParseElementAt(startPos, startLoc));
+ break;
+
+ case 137:
+ children.push(this.parseExprAtom());
+ break;
+
+ case 5:
+ {
+ const node = this.startNode();
+ this.setContext(types.brace);
+ this.next();
+
+ if (this.match(21)) {
+ children.push(this.jsxParseSpreadChild(node));
+ } else {
+ children.push(this.jsxParseExpressionContainer(node, types.j_expr));
+ }
+
+ break;
+ }
+
+ default:
+ throw this.unexpected();
+ }
+ }
+
+ if (isFragment(openingElement) && !isFragment(closingElement) && closingElement !== null) {
+ this.raise(JsxErrors.MissingClosingTagFragment, {
+ node: closingElement
+ });
+ } else if (!isFragment(openingElement) && isFragment(closingElement)) {
+ this.raise(JsxErrors.MissingClosingTagElement, {
+ node: closingElement
+ }, getQualifiedJSXName(openingElement.name));
+ } else if (!isFragment(openingElement) && !isFragment(closingElement)) {
+ if (getQualifiedJSXName(closingElement.name) !== getQualifiedJSXName(openingElement.name)) {
+ this.raise(JsxErrors.MissingClosingTagElement, {
+ node: closingElement
+ }, getQualifiedJSXName(openingElement.name));
+ }
+ }
+ }
+
+ if (isFragment(openingElement)) {
+ node.openingFragment = openingElement;
+ node.closingFragment = closingElement;
+ } else {
+ node.openingElement = openingElement;
+ node.closingElement = closingElement;
+ }
+
+ node.children = children;
+
+ if (this.match(47)) {
+ throw this.raise(JsxErrors.UnwrappedAdjacentJSXElements, {
+ at: this.state.startLoc
+ });
+ }
+
+ 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);
+ }
+
+ setContext(newContext) {
+ const {
+ context
+ } = this.state;
+ context[context.length - 1] = newContext;
+ }
+
+ parseExprAtom(refExpressionErrors) {
+ if (this.match(137)) {
+ return this.parseLiteral(this.state.value, "JSXText");
+ } else if (this.match(138)) {
+ return this.jsxParseElement();
+ } else if (this.match(47) && this.input.charCodeAt(this.state.pos) !== 33) {
+ this.replaceToken(138);
+ return this.jsxParseElement();
+ } else {
+ return super.parseExprAtom(refExpressionErrors);
+ }
+ }
+
+ skipSpace() {
+ const curContext = this.curContext();
+ if (!curContext.preserveSpace) super.skipSpace();
+ }
+
+ getTokenFromCode(code) {
+ const context = this.curContext();
+
+ if (context === types.j_expr) {
+ return this.jsxReadToken();
+ }
+
+ if (context === types.j_oTag || context === types.j_cTag) {
+ if (isIdentifierStart(code)) {
+ return this.jsxReadWord();
+ }
+
+ if (code === 62) {
+ ++this.state.pos;
+ return this.finishToken(139);
+ }
+
+ if ((code === 34 || code === 39) && context === types.j_oTag) {
+ return this.jsxReadString(code);
+ }
+ }
+
+ if (code === 60 && this.state.canStartJSXElement && this.input.charCodeAt(this.state.pos + 1) !== 33) {
+ ++this.state.pos;
+ return this.finishToken(138);
+ }
+
+ return super.getTokenFromCode(code);
+ }
+
+ updateContext(prevType) {
+ const {
+ context,
+ type
+ } = this.state;
+
+ if (type === 56 && prevType === 138) {
+ context.splice(-2, 2, types.j_cTag);
+ this.state.canStartJSXElement = false;
+ } else if (type === 138) {
+ context.push(types.j_oTag);
+ } else if (type === 139) {
+ const out = context[context.length - 1];
+
+ if (out === types.j_oTag && prevType === 56 || out === types.j_cTag) {
+ context.pop();
+ this.state.canStartJSXElement = context[context.length - 1] === types.j_expr;
+ } else {
+ this.setContext(types.j_expr);
+ this.state.canStartJSXElement = true;
+ }
+ } else {
+ this.state.canStartJSXElement = tokenComesBeforeExpression(type);
+ }
+ }
+
+});
+
+class TypeScriptScope extends Scope {
+ constructor(...args) {
+ super(...args);
+ this.types = new Set();
+ this.enums = new Set();
+ this.constEnums = new Set();
+ this.classes = new Set();
+ this.exportOnlyBindings = new Set();
+ }
+
+}
+
+class TypeScriptScopeHandler extends ScopeHandler {
+ createScope(flags) {
+ return new TypeScriptScope(flags);
+ }
+
+ declareName(name, bindingType, loc) {
+ const scope = this.currentScope();
+
+ if (bindingType & BIND_FLAGS_TS_EXPORT_ONLY) {
+ this.maybeExportDefined(scope, name);
+ scope.exportOnlyBindings.add(name);
+ return;
+ }
+
+ super.declareName(...arguments);
+
+ if (bindingType & BIND_KIND_TYPE) {
+ if (!(bindingType & BIND_KIND_VALUE)) {
+ this.checkRedeclarationInScope(scope, name, bindingType, loc);
+ this.maybeExportDefined(scope, name);
+ }
+
+ scope.types.add(name);
+ }
+
+ if (bindingType & BIND_FLAGS_TS_ENUM) scope.enums.add(name);
+ if (bindingType & BIND_FLAGS_TS_CONST_ENUM) scope.constEnums.add(name);
+ if (bindingType & BIND_FLAGS_CLASS) scope.classes.add(name);
+ }
+
+ isRedeclaredInScope(scope, name, bindingType) {
+ if (scope.enums.has(name)) {
+ if (bindingType & BIND_FLAGS_TS_ENUM) {
+ const isConst = !!(bindingType & BIND_FLAGS_TS_CONST_ENUM);
+ const wasConst = scope.constEnums.has(name);
+ return isConst !== wasConst;
+ }
+
+ return true;
+ }
+
+ if (bindingType & BIND_FLAGS_CLASS && scope.classes.has(name)) {
+ if (scope.lexical.has(name)) {
+ return !!(bindingType & BIND_KIND_VALUE);
+ } else {
+ return false;
+ }
+ }
+
+ if (bindingType & BIND_KIND_TYPE && scope.types.has(name)) {
+ return true;
+ }
+
+ return super.isRedeclaredInScope(...arguments);
+ }
+
+ checkLocalExport(id) {
+ const topLevelScope = this.scopeStack[0];
+ const {
+ name
+ } = id;
+
+ if (!topLevelScope.types.has(name) && !topLevelScope.exportOnlyBindings.has(name)) {
+ super.checkLocalExport(id);
+ }
+ }
+
+}
+
+function nonNull(x) {
+ if (x == null) {
+ throw new Error(`Unexpected ${x} value.`);
+ }
+
+ return x;
+}
+
+function assert(x) {
+ if (!x) {
+ throw new Error("Assert fail");
+ }
+}
+
+const TSErrors = makeErrorTemplates({
+ AbstractMethodHasImplementation: "Method '%0' cannot have an implementation because it is marked abstract.",
+ AbstractPropertyHasInitializer: "Property '%0' cannot have an initializer because it is marked abstract.",
+ AccesorCannotDeclareThisParameter: "'get' and 'set' accessors cannot declare 'this' parameters.",
+ AccesorCannotHaveTypeParameters: "An accessor cannot have type parameters.",
+ ClassMethodHasDeclare: "Class methods cannot have the 'declare' modifier.",
+ ClassMethodHasReadonly: "Class methods cannot have the 'readonly' modifier.",
+ ConstructorHasTypeParameters: "Type parameters cannot appear on a constructor declaration.",
+ DeclareAccessor: "'declare' is not allowed in %0ters.",
+ DeclareClassFieldHasInitializer: "Initializers are not allowed in ambient contexts.",
+ DeclareFunctionHasImplementation: "An implementation cannot be declared in ambient contexts.",
+ DuplicateAccessibilityModifier: "Accessibility modifier already seen.",
+ DuplicateModifier: "Duplicate modifier: '%0'.",
+ EmptyHeritageClauseType: "'%0' list cannot be empty.",
+ EmptyTypeArguments: "Type argument list cannot be empty.",
+ EmptyTypeParameters: "Type parameter list cannot be empty.",
+ ExpectedAmbientAfterExportDeclare: "'export declare' must be followed by an ambient declaration.",
+ ImportAliasHasImportType: "An import alias can not use 'import type'.",
+ IncompatibleModifiers: "'%0' modifier cannot be used with '%1' modifier.",
+ IndexSignatureHasAbstract: "Index signatures cannot have the 'abstract' modifier.",
+ IndexSignatureHasAccessibility: "Index signatures cannot have an accessibility modifier ('%0').",
+ IndexSignatureHasDeclare: "Index signatures cannot have the 'declare' modifier.",
+ IndexSignatureHasOverride: "'override' modifier cannot appear on an index signature.",
+ IndexSignatureHasStatic: "Index signatures cannot have the 'static' modifier.",
+ InvalidModifierOnTypeMember: "'%0' modifier cannot appear on a type member.",
+ InvalidModifiersOrder: "'%0' modifier must precede '%1' modifier.",
+ InvalidTupleMemberLabel: "Tuple members must be labeled with a simple identifier.",
+ MissingInterfaceName: "'interface' declarations must be followed by an identifier.",
+ MixedLabeledAndUnlabeledElements: "Tuple members must all have names or all not have names.",
+ NonAbstractClassHasAbstractMethod: "Abstract methods can only appear within an abstract class.",
+ NonClassMethodPropertyHasAbstractModifer: "'abstract' modifier can only appear on a class, method, or property declaration.",
+ OptionalTypeBeforeRequired: "A required element cannot follow an optional element.",
+ OverrideNotInSubClass: "This member cannot have an 'override' modifier because its containing class does not extend another class.",
+ PatternIsOptional: "A binding pattern parameter cannot be optional in an implementation signature.",
+ PrivateElementHasAbstract: "Private elements cannot have the 'abstract' modifier.",
+ PrivateElementHasAccessibility: "Private elements cannot have an accessibility modifier ('%0').",
+ ReadonlyForMethodSignature: "'readonly' modifier can only appear on a property declaration or index signature.",
+ ReservedArrowTypeParam: "This syntax is reserved in files with the .mts or .cts extension. Add a trailing comma, as in `() => ...`.",
+ ReservedTypeAssertion: "This syntax is reserved in files with the .mts or .cts extension. Use an `as` expression instead.",
+ SetAccesorCannotHaveOptionalParameter: "A 'set' accessor cannot have an optional parameter.",
+ SetAccesorCannotHaveRestParameter: "A 'set' accessor cannot have rest parameter.",
+ SetAccesorCannotHaveReturnType: "A 'set' accessor cannot have a return type annotation.",
+ StaticBlockCannotHaveModifier: "Static class blocks cannot have any modifier.",
+ TypeAnnotationAfterAssign: "Type annotations must come before default assignments, e.g. instead of `age = 25: number` use `age: number = 25`.",
+ TypeImportCannotSpecifyDefaultAndNamed: "A type-only import can specify a default import or named bindings, but not both.",
+ TypeModifierIsUsedInTypeExports: "The 'type' modifier cannot be used on a named export when 'export type' is used on its export statement.",
+ TypeModifierIsUsedInTypeImports: "The 'type' modifier cannot be used on a named import when 'import type' is used on its import statement.",
+ UnexpectedParameterModifier: "A parameter property is only allowed in a constructor implementation.",
+ UnexpectedReadonly: "'readonly' type modifier is only permitted on array and tuple literal types.",
+ UnexpectedTypeAnnotation: "Did not expect a type annotation here.",
+ UnexpectedTypeCastInParameter: "Unexpected type cast in parameter position.",
+ UnsupportedImportTypeArgument: "Argument in a type import must be a string literal.",
+ UnsupportedParameterPropertyKind: "A parameter property may not be declared using a binding pattern.",
+ UnsupportedSignatureParameterKind: "Name in a signature must be an Identifier, ObjectPattern or ArrayPattern, instead got %0."
+}, ErrorCodes.SyntaxError, "typescript");
+
+function keywordTypeFromName(value) {
+ switch (value) {
+ case "any":
+ return "TSAnyKeyword";
+
+ case "boolean":
+ return "TSBooleanKeyword";
+
+ case "bigint":
+ return "TSBigIntKeyword";
+
+ case "never":
+ return "TSNeverKeyword";
+
+ case "number":
+ return "TSNumberKeyword";
+
+ case "object":
+ return "TSObjectKeyword";
+
+ case "string":
+ return "TSStringKeyword";
+
+ case "symbol":
+ return "TSSymbolKeyword";
+
+ case "undefined":
+ return "TSUndefinedKeyword";
+
+ case "unknown":
+ return "TSUnknownKeyword";
+
+ default:
+ return undefined;
+ }
+}
+
+function tsIsAccessModifier(modifier) {
+ return modifier === "private" || modifier === "public" || modifier === "protected";
+}
+
+var typescript = (superClass => class extends superClass {
+ getScopeHandler() {
+ return TypeScriptScopeHandler;
+ }
+
+ tsIsIdentifier() {
+ return tokenIsIdentifier(this.state.type);
+ }
+
+ tsTokenCanFollowModifier() {
+ return (this.match(0) || this.match(5) || this.match(55) || this.match(21) || this.match(134) || this.isLiteralPropertyName()) && !this.hasPrecedingLineBreak();
+ }
+
+ tsNextTokenCanFollowModifier() {
+ this.next();
+ return this.tsTokenCanFollowModifier();
+ }
+
+ tsParseModifier(allowedModifiers, stopOnStartOfClassStaticBlock) {
+ if (!tokenIsIdentifier(this.state.type)) {
+ return undefined;
+ }
+
+ const modifier = this.state.value;
+
+ if (allowedModifiers.indexOf(modifier) !== -1) {
+ if (stopOnStartOfClassStaticBlock && this.tsIsStartOfStaticBlocks()) {
+ return undefined;
+ }
+
+ if (this.tsTryParse(this.tsNextTokenCanFollowModifier.bind(this))) {
+ return modifier;
+ }
+ }
+
+ return undefined;
+ }
+
+ tsParseModifiers(modified, allowedModifiers, disallowedModifiers, errorTemplate, stopOnStartOfClassStaticBlock) {
+ const enforceOrder = (loc, modifier, before, after) => {
+ if (modifier === before && modified[after]) {
+ this.raise(TSErrors.InvalidModifiersOrder, {
+ at: loc
+ }, before, after);
+ }
+ };
+
+ const incompatible = (loc, modifier, mod1, mod2) => {
+ if (modified[mod1] && modifier === mod2 || modified[mod2] && modifier === mod1) {
+ this.raise(TSErrors.IncompatibleModifiers, {
+ at: loc
+ }, mod1, mod2);
+ }
+ };
+
+ for (;;) {
+ const {
+ startLoc
+ } = this.state;
+ const modifier = this.tsParseModifier(allowedModifiers.concat(disallowedModifiers != null ? disallowedModifiers : []), stopOnStartOfClassStaticBlock);
+ if (!modifier) break;
+
+ if (tsIsAccessModifier(modifier)) {
+ if (modified.accessibility) {
+ this.raise(TSErrors.DuplicateAccessibilityModifier, {
+ at: startLoc
+ });
+ } else {
+ enforceOrder(startLoc, modifier, modifier, "override");
+ enforceOrder(startLoc, modifier, modifier, "static");
+ enforceOrder(startLoc, modifier, modifier, "readonly");
+ modified.accessibility = modifier;
+ }
+ } else {
+ if (Object.hasOwnProperty.call(modified, modifier)) {
+ this.raise(TSErrors.DuplicateModifier, {
+ at: startLoc
+ }, modifier);
+ } else {
+ enforceOrder(startLoc, modifier, "static", "readonly");
+ enforceOrder(startLoc, modifier, "static", "override");
+ enforceOrder(startLoc, modifier, "override", "readonly");
+ enforceOrder(startLoc, modifier, "abstract", "override");
+ incompatible(startLoc, modifier, "declare", "override");
+ incompatible(startLoc, modifier, "static", "abstract");
+ }
+
+ modified[modifier] = true;
+ }
+
+ if (disallowedModifiers != null && disallowedModifiers.includes(modifier)) {
+ this.raise(errorTemplate, {
+ at: startLoc
+ }, modifier);
+ }
+ }
+ }
+
+ tsIsListTerminator(kind) {
+ switch (kind) {
+ case "EnumMembers":
+ case "TypeMembers":
+ return this.match(8);
+
+ case "HeritageClauseElement":
+ return this.match(5);
+
+ case "TupleElementTypes":
+ return this.match(3);
+
+ case "TypeParametersOrArguments":
+ return this.match(48);
+ }
+
+ throw new Error("Unreachable");
+ }
+
+ tsParseList(kind, parseElement) {
+ const result = [];
+
+ while (!this.tsIsListTerminator(kind)) {
+ result.push(parseElement());
+ }
+
+ return result;
+ }
+
+ tsParseDelimitedList(kind, parseElement, refTrailingCommaPos) {
+ return nonNull(this.tsParseDelimitedListWorker(kind, parseElement, true, refTrailingCommaPos));
+ }
+
+ tsParseDelimitedListWorker(kind, parseElement, expectSuccess, refTrailingCommaPos) {
+ const result = [];
+ let trailingCommaPos = -1;
+
+ for (;;) {
+ if (this.tsIsListTerminator(kind)) {
+ break;
+ }
+
+ trailingCommaPos = -1;
+ const element = parseElement();
+
+ if (element == null) {
+ return undefined;
+ }
+
+ result.push(element);
+
+ if (this.eat(12)) {
+ trailingCommaPos = this.state.lastTokStart;
+ continue;
+ }
+
+ if (this.tsIsListTerminator(kind)) {
+ break;
+ }
+
+ if (expectSuccess) {
+ this.expect(12);
+ }
+
+ return undefined;
+ }
+
+ if (refTrailingCommaPos) {
+ refTrailingCommaPos.value = trailingCommaPos;
+ }
+
+ return result;
+ }
+
+ tsParseBracketedList(kind, parseElement, bracket, skipFirstToken, refTrailingCommaPos) {
+ if (!skipFirstToken) {
+ if (bracket) {
+ this.expect(0);
+ } else {
+ this.expect(47);
+ }
+ }
+
+ const result = this.tsParseDelimitedList(kind, parseElement, refTrailingCommaPos);
+
+ if (bracket) {
+ this.expect(3);
+ } else {
+ this.expect(48);
+ }
+
+ return result;
+ }
+
+ tsParseImportType() {
+ const node = this.startNode();
+ this.expect(83);
+ this.expect(10);
+
+ if (!this.match(129)) {
+ this.raise(TSErrors.UnsupportedImportTypeArgument, {
+ at: this.state.startLoc
+ });
+ }
+
+ node.argument = this.parseExprAtom();
+ this.expect(11);
+
+ if (this.eat(16)) {
+ node.qualifier = this.tsParseEntityName(true);
+ }
+
+ if (this.match(47)) {
+ node.typeParameters = this.tsParseTypeArguments();
+ }
+
+ return this.finishNode(node, "TSImportType");
+ }
+
+ tsParseEntityName(allowReservedWords) {
+ let entity = this.parseIdentifier();
+
+ while (this.eat(16)) {
+ const node = this.startNodeAtNode(entity);
+ node.left = entity;
+ node.right = this.parseIdentifier(allowReservedWords);
+ entity = this.finishNode(node, "TSQualifiedName");
+ }
+
+ return entity;
+ }
+
+ tsParseTypeReference() {
+ const node = this.startNode();
+ node.typeName = this.tsParseEntityName(false);
+
+ if (!this.hasPrecedingLineBreak() && this.match(47)) {
+ node.typeParameters = this.tsParseTypeArguments();
+ }
+
+ return this.finishNode(node, "TSTypeReference");
+ }
+
+ tsParseThisTypePredicate(lhs) {
+ this.next();
+ const node = this.startNodeAtNode(lhs);
+ node.parameterName = lhs;
+ node.typeAnnotation = this.tsParseTypeAnnotation(false);
+ node.asserts = false;
+ return this.finishNode(node, "TSTypePredicate");
+ }
+
+ tsParseThisTypeNode() {
+ const node = this.startNode();
+ this.next();
+ return this.finishNode(node, "TSThisType");
+ }
+
+ tsParseTypeQuery() {
+ const node = this.startNode();
+ this.expect(87);
+
+ if (this.match(83)) {
+ node.exprName = this.tsParseImportType();
+ } else {
+ node.exprName = this.tsParseEntityName(true);
+ }
+
+ return this.finishNode(node, "TSTypeQuery");
+ }
+
+ tsParseTypeParameter() {
+ const node = this.startNode();
+ node.name = this.tsParseTypeParameterName();
+ node.constraint = this.tsEatThenParseType(81);
+ node.default = this.tsEatThenParseType(29);
+ return this.finishNode(node, "TSTypeParameter");
+ }
+
+ tsTryParseTypeParameters() {
+ if (this.match(47)) {
+ return this.tsParseTypeParameters();
+ }
+ }
+
+ tsParseTypeParameters() {
+ const node = this.startNode();
+
+ if (this.match(47) || this.match(138)) {
+ this.next();
+ } else {
+ this.unexpected();
+ }
+
+ const refTrailingCommaPos = {
+ value: -1
+ };
+ node.params = this.tsParseBracketedList("TypeParametersOrArguments", this.tsParseTypeParameter.bind(this), false, true, refTrailingCommaPos);
+
+ if (node.params.length === 0) {
+ this.raise(TSErrors.EmptyTypeParameters, {
+ node
+ });
+ }
+
+ if (refTrailingCommaPos.value !== -1) {
+ this.addExtra(node, "trailingComma", refTrailingCommaPos.value);
+ }
+
+ return this.finishNode(node, "TSTypeParameterDeclaration");
+ }
+
+ tsTryNextParseConstantContext() {
+ if (this.lookahead().type === 75) {
+ this.next();
+ return this.tsParseTypeReference();
+ }
+
+ return null;
+ }
+
+ tsFillSignature(returnToken, signature) {
+ const returnTokenRequired = returnToken === 19;
+ const paramsKey = "parameters";
+ const returnTypeKey = "typeAnnotation";
+ signature.typeParameters = this.tsTryParseTypeParameters();
+ this.expect(10);
+ signature[paramsKey] = this.tsParseBindingListForSignature();
+
+ if (returnTokenRequired) {
+ signature[returnTypeKey] = this.tsParseTypeOrTypePredicateAnnotation(returnToken);
+ } else if (this.match(returnToken)) {
+ signature[returnTypeKey] = this.tsParseTypeOrTypePredicateAnnotation(returnToken);
+ }
+ }
+
+ tsParseBindingListForSignature() {
+ return this.parseBindingList(11, 41).map(pattern => {
+ if (pattern.type !== "Identifier" && pattern.type !== "RestElement" && pattern.type !== "ObjectPattern" && pattern.type !== "ArrayPattern") {
+ this.raise(TSErrors.UnsupportedSignatureParameterKind, {
+ node: pattern
+ }, pattern.type);
+ }
+
+ return pattern;
+ });
+ }
+
+ tsParseTypeMemberSemicolon() {
+ if (!this.eat(12) && !this.isLineTerminator()) {
+ this.expect(13);
+ }
+ }
+
+ tsParseSignatureMember(kind, node) {
+ this.tsFillSignature(14, node);
+ this.tsParseTypeMemberSemicolon();
+ return this.finishNode(node, kind);
+ }
+
+ tsIsUnambiguouslyIndexSignature() {
+ this.next();
+
+ if (tokenIsIdentifier(this.state.type)) {
+ this.next();
+ return this.match(14);
+ }
+
+ return false;
+ }
+
+ tsTryParseIndexSignature(node) {
+ if (!(this.match(0) && this.tsLookAhead(this.tsIsUnambiguouslyIndexSignature.bind(this)))) {
+ return undefined;
+ }
+
+ this.expect(0);
+ const id = this.parseIdentifier();
+ id.typeAnnotation = this.tsParseTypeAnnotation();
+ this.resetEndLocation(id);
+ this.expect(3);
+ node.parameters = [id];
+ const type = this.tsTryParseTypeAnnotation();
+ if (type) node.typeAnnotation = type;
+ this.tsParseTypeMemberSemicolon();
+ return this.finishNode(node, "TSIndexSignature");
+ }
+
+ tsParsePropertyOrMethodSignature(node, readonly) {
+ if (this.eat(17)) node.optional = true;
+ const nodeAny = node;
+
+ if (this.match(10) || this.match(47)) {
+ if (readonly) {
+ this.raise(TSErrors.ReadonlyForMethodSignature, {
+ node
+ });
+ }
+
+ const method = nodeAny;
+
+ if (method.kind && this.match(47)) {
+ this.raise(TSErrors.AccesorCannotHaveTypeParameters, {
+ at: this.state.curPosition()
+ });
+ }
+
+ this.tsFillSignature(14, method);
+ this.tsParseTypeMemberSemicolon();
+ const paramsKey = "parameters";
+ const returnTypeKey = "typeAnnotation";
+
+ if (method.kind === "get") {
+ if (method[paramsKey].length > 0) {
+ this.raise(ErrorMessages.BadGetterArity, {
+ at: this.state.curPosition()
+ });
+
+ if (this.isThisParam(method[paramsKey][0])) {
+ this.raise(TSErrors.AccesorCannotDeclareThisParameter, {
+ at: this.state.curPosition()
+ });
+ }
+ }
+ } else if (method.kind === "set") {
+ if (method[paramsKey].length !== 1) {
+ this.raise(ErrorMessages.BadSetterArity, {
+ at: this.state.curPosition()
+ });
+ } else {
+ const firstParameter = method[paramsKey][0];
+
+ if (this.isThisParam(firstParameter)) {
+ this.raise(TSErrors.AccesorCannotDeclareThisParameter, {
+ at: this.state.curPosition()
+ });
+ }
+
+ if (firstParameter.type === "Identifier" && firstParameter.optional) {
+ this.raise(TSErrors.SetAccesorCannotHaveOptionalParameter, {
+ at: this.state.curPosition()
+ });
+ }
+
+ if (firstParameter.type === "RestElement") {
+ this.raise(TSErrors.SetAccesorCannotHaveRestParameter, {
+ at: this.state.curPosition()
+ });
+ }
+ }
+
+ if (method[returnTypeKey]) {
+ this.raise(TSErrors.SetAccesorCannotHaveReturnType, {
+ node: method[returnTypeKey]
+ });
+ }
+ } else {
+ method.kind = "method";
+ }
+
+ return this.finishNode(method, "TSMethodSignature");
+ } else {
+ const property = nodeAny;
+ if (readonly) property.readonly = true;
+ const type = this.tsTryParseTypeAnnotation();
+ if (type) property.typeAnnotation = type;
+ this.tsParseTypeMemberSemicolon();
+ return this.finishNode(property, "TSPropertySignature");
+ }
+ }
+
+ tsParseTypeMember() {
+ const node = this.startNode();
+
+ if (this.match(10) || this.match(47)) {
+ return this.tsParseSignatureMember("TSCallSignatureDeclaration", node);
+ }
+
+ if (this.match(77)) {
+ const id = this.startNode();
+ this.next();
+
+ if (this.match(10) || this.match(47)) {
+ return this.tsParseSignatureMember("TSConstructSignatureDeclaration", node);
+ } else {
+ node.key = this.createIdentifier(id, "new");
+ return this.tsParsePropertyOrMethodSignature(node, false);
+ }
+ }
+
+ this.tsParseModifiers(node, ["readonly"], ["declare", "abstract", "private", "protected", "public", "static", "override"], TSErrors.InvalidModifierOnTypeMember);
+ const idx = this.tsTryParseIndexSignature(node);
+
+ if (idx) {
+ return idx;
+ }
+
+ this.parsePropertyName(node);
+
+ if (!node.computed && node.key.type === "Identifier" && (node.key.name === "get" || node.key.name === "set") && this.tsTokenCanFollowModifier()) {
+ node.kind = node.key.name;
+ this.parsePropertyName(node);
+ }
+
+ return this.tsParsePropertyOrMethodSignature(node, !!node.readonly);
+ }
+
+ tsParseTypeLiteral() {
+ const node = this.startNode();
+ node.members = this.tsParseObjectTypeMembers();
+ return this.finishNode(node, "TSTypeLiteral");
+ }
+
+ tsParseObjectTypeMembers() {
+ this.expect(5);
+ const members = this.tsParseList("TypeMembers", this.tsParseTypeMember.bind(this));
+ this.expect(8);
+ return members;
+ }
+
+ tsIsStartOfMappedType() {
+ this.next();
+
+ if (this.eat(53)) {
+ return this.isContextual(118);
+ }
+
+ if (this.isContextual(118)) {
+ this.next();
+ }
+
+ if (!this.match(0)) {
+ return false;
+ }
+
+ this.next();
+
+ if (!this.tsIsIdentifier()) {
+ return false;
+ }
+
+ this.next();
+ return this.match(58);
+ }
+
+ tsParseMappedTypeParameter() {
+ const node = this.startNode();
+ node.name = this.tsParseTypeParameterName();
+ node.constraint = this.tsExpectThenParseType(58);
+ return this.finishNode(node, "TSTypeParameter");
+ }
+
+ tsParseMappedType() {
+ const node = this.startNode();
+ this.expect(5);
+
+ if (this.match(53)) {
+ node.readonly = this.state.value;
+ this.next();
+ this.expectContextual(118);
+ } else if (this.eatContextual(118)) {
+ node.readonly = true;
+ }
+
+ this.expect(0);
+ node.typeParameter = this.tsParseMappedTypeParameter();
+ node.nameType = this.eatContextual(93) ? this.tsParseType() : null;
+ this.expect(3);
+
+ if (this.match(53)) {
+ node.optional = this.state.value;
+ this.next();
+ this.expect(17);
+ } else if (this.eat(17)) {
+ node.optional = true;
+ }
+
+ node.typeAnnotation = this.tsTryParseType();
+ this.semicolon();
+ this.expect(8);
+ return this.finishNode(node, "TSMappedType");
+ }
+
+ tsParseTupleType() {
+ const node = this.startNode();
+ node.elementTypes = this.tsParseBracketedList("TupleElementTypes", this.tsParseTupleElementType.bind(this), true, false);
+ let seenOptionalElement = false;
+ let labeledElements = null;
+ node.elementTypes.forEach(elementNode => {
+ var _labeledElements;
+
+ let {
+ type
+ } = elementNode;
+
+ if (seenOptionalElement && type !== "TSRestType" && type !== "TSOptionalType" && !(type === "TSNamedTupleMember" && elementNode.optional)) {
+ this.raise(TSErrors.OptionalTypeBeforeRequired, {
+ node: elementNode
+ });
+ }
+
+ seenOptionalElement = seenOptionalElement || type === "TSNamedTupleMember" && elementNode.optional || type === "TSOptionalType";
+
+ if (type === "TSRestType") {
+ elementNode = elementNode.typeAnnotation;
+ type = elementNode.type;
+ }
+
+ const isLabeled = type === "TSNamedTupleMember";
+ labeledElements = (_labeledElements = labeledElements) != null ? _labeledElements : isLabeled;
+
+ if (labeledElements !== isLabeled) {
+ this.raise(TSErrors.MixedLabeledAndUnlabeledElements, {
+ node: elementNode
+ });
+ }
+ });
+ return this.finishNode(node, "TSTupleType");
+ }
+
+ tsParseTupleElementType() {
+ const {
+ start: startPos,
+ startLoc
+ } = this.state;
+ const rest = this.eat(21);
+ let type = this.tsParseType();
+ const optional = this.eat(17);
+ const labeled = this.eat(14);
+
+ if (labeled) {
+ const labeledNode = this.startNodeAtNode(type);
+ labeledNode.optional = optional;
+
+ if (type.type === "TSTypeReference" && !type.typeParameters && type.typeName.type === "Identifier") {
+ labeledNode.label = type.typeName;
+ } else {
+ this.raise(TSErrors.InvalidTupleMemberLabel, {
+ node: type
+ });
+ labeledNode.label = type;
+ }
+
+ labeledNode.elementType = this.tsParseType();
+ type = this.finishNode(labeledNode, "TSNamedTupleMember");
+ } else if (optional) {
+ const optionalTypeNode = this.startNodeAtNode(type);
+ optionalTypeNode.typeAnnotation = type;
+ type = this.finishNode(optionalTypeNode, "TSOptionalType");
+ }
+
+ if (rest) {
+ const restNode = this.startNodeAt(startPos, startLoc);
+ restNode.typeAnnotation = type;
+ type = this.finishNode(restNode, "TSRestType");
+ }
+
+ return type;
+ }
+
+ tsParseParenthesizedType() {
+ const node = this.startNode();
+ this.expect(10);
+ node.typeAnnotation = this.tsParseType();
+ this.expect(11);
+ return this.finishNode(node, "TSParenthesizedType");
+ }
+
+ tsParseFunctionOrConstructorType(type, abstract) {
+ const node = this.startNode();
+
+ if (type === "TSConstructorType") {
+ node.abstract = !!abstract;
+ if (abstract) this.next();
+ this.next();
+ }
+
+ this.tsFillSignature(19, node);
+ return this.finishNode(node, type);
+ }
+
+ tsParseLiteralTypeNode() {
+ const node = this.startNode();
+
+ node.literal = (() => {
+ switch (this.state.type) {
+ case 130:
+ case 131:
+ case 129:
+ case 85:
+ case 86:
+ return this.parseExprAtom();
+
+ default:
+ throw this.unexpected();
+ }
+ })();
+
+ return this.finishNode(node, "TSLiteralType");
+ }
+
+ tsParseTemplateLiteralType() {
+ const node = this.startNode();
+ node.literal = this.parseTemplate(false);
+ return this.finishNode(node, "TSLiteralType");
+ }
+
+ parseTemplateSubstitution() {
+ if (this.state.inType) return this.tsParseType();
+ return super.parseTemplateSubstitution();
+ }
+
+ tsParseThisTypeOrThisTypePredicate() {
+ const thisKeyword = this.tsParseThisTypeNode();
+
+ if (this.isContextual(113) && !this.hasPrecedingLineBreak()) {
+ return this.tsParseThisTypePredicate(thisKeyword);
+ } else {
+ return thisKeyword;
+ }
+ }
+
+ tsParseNonArrayType() {
+ switch (this.state.type) {
+ case 129:
+ case 130:
+ case 131:
+ case 85:
+ case 86:
+ return this.tsParseLiteralTypeNode();
+
+ case 53:
+ if (this.state.value === "-") {
+ const node = this.startNode();
+ const nextToken = this.lookahead();
+
+ if (nextToken.type !== 130 && nextToken.type !== 131) {
+ throw this.unexpected();
+ }
+
+ node.literal = this.parseMaybeUnary();
+ return this.finishNode(node, "TSLiteralType");
+ }
+
+ break;
+
+ case 78:
+ return this.tsParseThisTypeOrThisTypePredicate();
+
+ case 87:
+ return this.tsParseTypeQuery();
+
+ case 83:
+ return this.tsParseImportType();
+
+ case 5:
+ return this.tsLookAhead(this.tsIsStartOfMappedType.bind(this)) ? this.tsParseMappedType() : this.tsParseTypeLiteral();
+
+ case 0:
+ return this.tsParseTupleType();
+
+ case 10:
+ return this.tsParseParenthesizedType();
+
+ case 25:
+ case 24:
+ return this.tsParseTemplateLiteralType();
+
+ default:
+ {
+ const {
+ type
+ } = this.state;
+
+ if (tokenIsIdentifier(type) || type === 88 || type === 84) {
+ const nodeType = type === 88 ? "TSVoidKeyword" : type === 84 ? "TSNullKeyword" : keywordTypeFromName(this.state.value);
+
+ if (nodeType !== undefined && this.lookaheadCharCode() !== 46) {
+ const node = this.startNode();
+ this.next();
+ return this.finishNode(node, nodeType);
+ }
+
+ return this.tsParseTypeReference();
+ }
+ }
+ }
+
+ throw this.unexpected();
+ }
+
+ tsParseArrayTypeOrHigher() {
+ let type = this.tsParseNonArrayType();
+
+ while (!this.hasPrecedingLineBreak() && this.eat(0)) {
+ if (this.match(3)) {
+ const node = this.startNodeAtNode(type);
+ node.elementType = type;
+ this.expect(3);
+ type = this.finishNode(node, "TSArrayType");
+ } else {
+ const node = this.startNodeAtNode(type);
+ node.objectType = type;
+ node.indexType = this.tsParseType();
+ this.expect(3);
+ type = this.finishNode(node, "TSIndexedAccessType");
+ }
+ }
+
+ return type;
+ }
+
+ tsParseTypeOperator() {
+ const node = this.startNode();
+ const operator = this.state.value;
+ this.next();
+ node.operator = operator;
+ node.typeAnnotation = this.tsParseTypeOperatorOrHigher();
+
+ if (operator === "readonly") {
+ this.tsCheckTypeAnnotationForReadOnly(node);
+ }
+
+ return this.finishNode(node, "TSTypeOperator");
+ }
+
+ tsCheckTypeAnnotationForReadOnly(node) {
+ switch (node.typeAnnotation.type) {
+ case "TSTupleType":
+ case "TSArrayType":
+ return;
+
+ default:
+ this.raise(TSErrors.UnexpectedReadonly, {
+ node
+ });
+ }
+ }
+
+ tsParseInferType() {
+ const node = this.startNode();
+ this.expectContextual(112);
+ const typeParameter = this.startNode();
+ typeParameter.name = this.tsParseTypeParameterName();
+ node.typeParameter = this.finishNode(typeParameter, "TSTypeParameter");
+ return this.finishNode(node, "TSInferType");
+ }
+
+ tsParseTypeOperatorOrHigher() {
+ const isTypeOperator = tokenIsTSTypeOperator(this.state.type) && !this.state.containsEsc;
+ return isTypeOperator ? this.tsParseTypeOperator() : this.isContextual(112) ? this.tsParseInferType() : this.tsParseArrayTypeOrHigher();
+ }
+
+ tsParseUnionOrIntersectionType(kind, parseConstituentType, operator) {
+ const node = this.startNode();
+ const hasLeadingOperator = this.eat(operator);
+ const types = [];
+
+ do {
+ types.push(parseConstituentType());
+ } while (this.eat(operator));
+
+ if (types.length === 1 && !hasLeadingOperator) {
+ return types[0];
+ }
+
+ node.types = types;
+ return this.finishNode(node, kind);
+ }
+
+ tsParseIntersectionTypeOrHigher() {
+ return this.tsParseUnionOrIntersectionType("TSIntersectionType", this.tsParseTypeOperatorOrHigher.bind(this), 45);
+ }
+
+ tsParseUnionTypeOrHigher() {
+ return this.tsParseUnionOrIntersectionType("TSUnionType", this.tsParseIntersectionTypeOrHigher.bind(this), 43);
+ }
+
+ tsIsStartOfFunctionType() {
+ if (this.match(47)) {
+ return true;
+ }
+
+ return this.match(10) && this.tsLookAhead(this.tsIsUnambiguouslyStartOfFunctionType.bind(this));
+ }
+
+ tsSkipParameterStart() {
+ if (tokenIsIdentifier(this.state.type) || this.match(78)) {
+ this.next();
+ return true;
+ }
+
+ if (this.match(5)) {
+ let braceStackCounter = 1;
+ this.next();
+
+ while (braceStackCounter > 0) {
+ if (this.match(5)) {
+ ++braceStackCounter;
+ } else if (this.match(8)) {
+ --braceStackCounter;
+ }
+
+ this.next();
+ }
+
+ return true;
+ }
+
+ if (this.match(0)) {
+ let braceStackCounter = 1;
+ this.next();
+
+ while (braceStackCounter > 0) {
+ if (this.match(0)) {
+ ++braceStackCounter;
+ } else if (this.match(3)) {
+ --braceStackCounter;
+ }
+
+ this.next();
+ }
+
+ return true;
+ }
+
+ return false;
+ }
+
+ tsIsUnambiguouslyStartOfFunctionType() {
+ this.next();
+
+ if (this.match(11) || this.match(21)) {
+ return true;
+ }
+
+ if (this.tsSkipParameterStart()) {
+ if (this.match(14) || this.match(12) || this.match(17) || this.match(29)) {
+ return true;
+ }
+
+ if (this.match(11)) {
+ this.next();
+
+ if (this.match(19)) {
+ return true;
+ }
+ }
+ }
+
+ return false;
+ }
+
+ tsParseTypeOrTypePredicateAnnotation(returnToken) {
+ return this.tsInType(() => {
+ const t = this.startNode();
+ this.expect(returnToken);
+ const node = this.startNode();
+ const asserts = !!this.tsTryParse(this.tsParseTypePredicateAsserts.bind(this));
+
+ if (asserts && this.match(78)) {
+ let thisTypePredicate = this.tsParseThisTypeOrThisTypePredicate();
+
+ if (thisTypePredicate.type === "TSThisType") {
+ node.parameterName = thisTypePredicate;
+ node.asserts = true;
+ node.typeAnnotation = null;
+ thisTypePredicate = this.finishNode(node, "TSTypePredicate");
+ } else {
+ this.resetStartLocationFromNode(thisTypePredicate, node);
+ thisTypePredicate.asserts = true;
+ }
+
+ t.typeAnnotation = thisTypePredicate;
+ return this.finishNode(t, "TSTypeAnnotation");
+ }
+
+ const typePredicateVariable = this.tsIsIdentifier() && this.tsTryParse(this.tsParseTypePredicatePrefix.bind(this));
+
+ if (!typePredicateVariable) {
+ if (!asserts) {
+ return this.tsParseTypeAnnotation(false, t);
+ }
+
+ node.parameterName = this.parseIdentifier();
+ node.asserts = asserts;
+ node.typeAnnotation = null;
+ t.typeAnnotation = this.finishNode(node, "TSTypePredicate");
+ return this.finishNode(t, "TSTypeAnnotation");
+ }
+
+ const type = this.tsParseTypeAnnotation(false);
+ node.parameterName = typePredicateVariable;
+ node.typeAnnotation = type;
+ node.asserts = asserts;
+ t.typeAnnotation = this.finishNode(node, "TSTypePredicate");
+ return this.finishNode(t, "TSTypeAnnotation");
+ });
+ }
+
+ tsTryParseTypeOrTypePredicateAnnotation() {
+ return this.match(14) ? this.tsParseTypeOrTypePredicateAnnotation(14) : undefined;
+ }
+
+ tsTryParseTypeAnnotation() {
+ return this.match(14) ? this.tsParseTypeAnnotation() : undefined;
+ }
+
+ tsTryParseType() {
+ return this.tsEatThenParseType(14);
+ }
+
+ tsParseTypePredicatePrefix() {
+ const id = this.parseIdentifier();
+
+ if (this.isContextual(113) && !this.hasPrecedingLineBreak()) {
+ this.next();
+ return id;
+ }
+ }
+
+ tsParseTypePredicateAsserts() {
+ if (this.state.type !== 106) {
+ return false;
+ }
+
+ const containsEsc = this.state.containsEsc;
+ this.next();
+
+ if (!tokenIsIdentifier(this.state.type) && !this.match(78)) {
+ return false;
+ }
+
+ if (containsEsc) {
+ this.raise(ErrorMessages.InvalidEscapedReservedWord, {
+ at: this.state.lastTokStartLoc
+ }, "asserts");
+ }
+
+ return true;
+ }
+
+ tsParseTypeAnnotation(eatColon = true, t = this.startNode()) {
+ this.tsInType(() => {
+ if (eatColon) this.expect(14);
+ t.typeAnnotation = this.tsParseType();
+ });
+ return this.finishNode(t, "TSTypeAnnotation");
+ }
+
+ tsParseType() {
+ assert(this.state.inType);
+ const type = this.tsParseNonConditionalType();
+
+ if (this.hasPrecedingLineBreak() || !this.eat(81)) {
+ return type;
+ }
+
+ const node = this.startNodeAtNode(type);
+ node.checkType = type;
+ node.extendsType = this.tsParseNonConditionalType();
+ this.expect(17);
+ node.trueType = this.tsParseType();
+ this.expect(14);
+ node.falseType = this.tsParseType();
+ return this.finishNode(node, "TSConditionalType");
+ }
+
+ isAbstractConstructorSignature() {
+ return this.isContextual(120) && this.lookahead().type === 77;
+ }
+
+ tsParseNonConditionalType() {
+ if (this.tsIsStartOfFunctionType()) {
+ return this.tsParseFunctionOrConstructorType("TSFunctionType");
+ }
+
+ if (this.match(77)) {
+ return this.tsParseFunctionOrConstructorType("TSConstructorType");
+ } else if (this.isAbstractConstructorSignature()) {
+ return this.tsParseFunctionOrConstructorType("TSConstructorType", true);
+ }
+
+ return this.tsParseUnionTypeOrHigher();
+ }
+
+ tsParseTypeAssertion() {
+ if (this.getPluginOption("typescript", "disallowAmbiguousJSXLike")) {
+ this.raise(TSErrors.ReservedTypeAssertion, {
+ at: this.state.startLoc
+ });
+ }
+
+ const node = this.startNode();
+
+ const _const = this.tsTryNextParseConstantContext();
+
+ node.typeAnnotation = _const || this.tsNextThenParseType();
+ this.expect(48);
+ node.expression = this.parseMaybeUnary();
+ return this.finishNode(node, "TSTypeAssertion");
+ }
+
+ tsParseHeritageClause(descriptor) {
+ const originalStartLoc = this.state.startLoc;
+ const delimitedList = this.tsParseDelimitedList("HeritageClauseElement", this.tsParseExpressionWithTypeArguments.bind(this));
+
+ if (!delimitedList.length) {
+ this.raise(TSErrors.EmptyHeritageClauseType, {
+ at: originalStartLoc
+ }, descriptor);
+ }
+
+ return delimitedList;
+ }
+
+ tsParseExpressionWithTypeArguments() {
+ const node = this.startNode();
+ node.expression = this.tsParseEntityName(false);
+
+ if (this.match(47)) {
+ node.typeParameters = this.tsParseTypeArguments();
+ }
+
+ return this.finishNode(node, "TSExpressionWithTypeArguments");
+ }
+
+ tsParseInterfaceDeclaration(node) {
+ if (tokenIsIdentifier(this.state.type)) {
+ node.id = this.parseIdentifier();
+ this.checkLVal(node.id, "typescript interface declaration", BIND_TS_INTERFACE);
+ } else {
+ node.id = null;
+ this.raise(TSErrors.MissingInterfaceName, {
+ at: this.state.startLoc
+ });
+ }
+
+ node.typeParameters = this.tsTryParseTypeParameters();
+
+ if (this.eat(81)) {
+ node.extends = this.tsParseHeritageClause("extends");
+ }
+
+ const body = this.startNode();
+ body.body = this.tsInType(this.tsParseObjectTypeMembers.bind(this));
+ node.body = this.finishNode(body, "TSInterfaceBody");
+ return this.finishNode(node, "TSInterfaceDeclaration");
+ }
+
+ tsParseTypeAliasDeclaration(node) {
+ node.id = this.parseIdentifier();
+ this.checkLVal(node.id, "typescript type alias", BIND_TS_TYPE);
+ node.typeParameters = this.tsTryParseTypeParameters();
+ node.typeAnnotation = this.tsInType(() => {
+ this.expect(29);
+
+ if (this.isContextual(111) && this.lookahead().type !== 16) {
+ const node = this.startNode();
+ this.next();
+ return this.finishNode(node, "TSIntrinsicKeyword");
+ }
+
+ return this.tsParseType();
+ });
+ this.semicolon();
+ return this.finishNode(node, "TSTypeAliasDeclaration");
+ }
+
+ tsInNoContext(cb) {
+ const oldContext = this.state.context;
+ this.state.context = [oldContext[0]];
+
+ try {
+ return cb();
+ } finally {
+ this.state.context = oldContext;
+ }
+ }
+
+ tsInType(cb) {
+ const oldInType = this.state.inType;
+ this.state.inType = true;
+
+ try {
+ return cb();
+ } finally {
+ this.state.inType = oldInType;
+ }
+ }
+
+ tsEatThenParseType(token) {
+ return !this.match(token) ? undefined : this.tsNextThenParseType();
+ }
+
+ tsExpectThenParseType(token) {
+ return this.tsDoThenParseType(() => this.expect(token));
+ }
+
+ tsNextThenParseType() {
+ return this.tsDoThenParseType(() => this.next());
+ }
+
+ tsDoThenParseType(cb) {
+ return this.tsInType(() => {
+ cb();
+ return this.tsParseType();
+ });
+ }
+
+ tsParseEnumMember() {
+ const node = this.startNode();
+ node.id = this.match(129) ? this.parseExprAtom() : this.parseIdentifier(true);
+
+ if (this.eat(29)) {
+ node.initializer = this.parseMaybeAssignAllowIn();
+ }
+
+ return this.finishNode(node, "TSEnumMember");
+ }
+
+ tsParseEnumDeclaration(node, isConst) {
+ if (isConst) node.const = true;
+ node.id = this.parseIdentifier();
+ this.checkLVal(node.id, "typescript enum declaration", isConst ? BIND_TS_CONST_ENUM : BIND_TS_ENUM);
+ this.expect(5);
+ node.members = this.tsParseDelimitedList("EnumMembers", this.tsParseEnumMember.bind(this));
+ this.expect(8);
+ return this.finishNode(node, "TSEnumDeclaration");
+ }
+
+ tsParseModuleBlock() {
+ const node = this.startNode();
+ this.scope.enter(SCOPE_OTHER);
+ this.expect(5);
+ this.parseBlockOrModuleBlockBody(node.body = [], undefined, true, 8);
+ this.scope.exit();
+ return this.finishNode(node, "TSModuleBlock");
+ }
+
+ tsParseModuleOrNamespaceDeclaration(node, nested = false) {
+ node.id = this.parseIdentifier();
+
+ if (!nested) {
+ this.checkLVal(node.id, "module or namespace declaration", BIND_TS_NAMESPACE);
+ }
+
+ if (this.eat(16)) {
+ const inner = this.startNode();
+ this.tsParseModuleOrNamespaceDeclaration(inner, true);
+ node.body = inner;
+ } else {
+ this.scope.enter(SCOPE_TS_MODULE);
+ this.prodParam.enter(PARAM);
+ node.body = this.tsParseModuleBlock();
+ this.prodParam.exit();
+ this.scope.exit();
+ }
+
+ return this.finishNode(node, "TSModuleDeclaration");
+ }
+
+ tsParseAmbientExternalModuleDeclaration(node) {
+ if (this.isContextual(109)) {
+ node.global = true;
+ node.id = this.parseIdentifier();
+ } else if (this.match(129)) {
+ node.id = this.parseExprAtom();
+ } else {
+ this.unexpected();
+ }
+
+ if (this.match(5)) {
+ this.scope.enter(SCOPE_TS_MODULE);
+ this.prodParam.enter(PARAM);
+ node.body = this.tsParseModuleBlock();
+ this.prodParam.exit();
+ this.scope.exit();
+ } else {
+ this.semicolon();
+ }
+
+ return this.finishNode(node, "TSModuleDeclaration");
+ }
+
+ tsParseImportEqualsDeclaration(node, isExport) {
+ node.isExport = isExport || false;
+ node.id = this.parseIdentifier();
+ this.checkLVal(node.id, "import equals declaration", BIND_LEXICAL);
+ this.expect(29);
+ const moduleReference = this.tsParseModuleReference();
+
+ if (node.importKind === "type" && moduleReference.type !== "TSExternalModuleReference") {
+ this.raise(TSErrors.ImportAliasHasImportType, {
+ node: moduleReference
+ });
+ }
+
+ node.moduleReference = moduleReference;
+ this.semicolon();
+ return this.finishNode(node, "TSImportEqualsDeclaration");
+ }
+
+ tsIsExternalModuleReference() {
+ return this.isContextual(116) && this.lookaheadCharCode() === 40;
+ }
+
+ tsParseModuleReference() {
+ return this.tsIsExternalModuleReference() ? this.tsParseExternalModuleReference() : this.tsParseEntityName(false);
+ }
+
+ tsParseExternalModuleReference() {
+ const node = this.startNode();
+ this.expectContextual(116);
+ this.expect(10);
+
+ if (!this.match(129)) {
+ throw this.unexpected();
+ }
+
+ node.expression = this.parseExprAtom();
+ this.expect(11);
+ return this.finishNode(node, "TSExternalModuleReference");
+ }
+
+ tsLookAhead(f) {
+ const state = this.state.clone();
+ const res = f();
+ this.state = state;
+ return res;
+ }
+
+ tsTryParseAndCatch(f) {
+ const result = this.tryParse(abort => f() || abort());
+ if (result.aborted || !result.node) return undefined;
+ if (result.error) this.state = result.failState;
+ return result.node;
+ }
+
+ tsTryParse(f) {
+ const state = this.state.clone();
+ const result = f();
+
+ if (result !== undefined && result !== false) {
+ return result;
+ } else {
+ this.state = state;
+ return undefined;
+ }
+ }
+
+ tsTryParseDeclare(nany) {
+ if (this.isLineTerminator()) {
+ return;
+ }
+
+ let starttype = this.state.type;
+ let kind;
+
+ if (this.isContextual(99)) {
+ starttype = 74;
+ kind = "let";
+ }
+
+ return this.tsInAmbientContext(() => {
+ switch (starttype) {
+ case 68:
+ nany.declare = true;
+ return this.parseFunctionStatement(nany, false, true);
+
+ case 80:
+ nany.declare = true;
+ return this.parseClass(nany, true, false);
+
+ case 75:
+ if (this.match(75) && this.isLookaheadContextual("enum")) {
+ this.expect(75);
+ this.expectContextual(122);
+ return this.tsParseEnumDeclaration(nany, true);
+ }
+
+ case 74:
+ kind = kind || this.state.value;
+ return this.parseVarStatement(nany, kind);
+
+ case 109:
+ return this.tsParseAmbientExternalModuleDeclaration(nany);
+
+ default:
+ {
+ if (tokenIsIdentifier(starttype)) {
+ return this.tsParseDeclaration(nany, this.state.value, true);
+ }
+ }
+ }
+ });
+ }
+
+ tsTryParseExportDeclaration() {
+ return this.tsParseDeclaration(this.startNode(), this.state.value, true);
+ }
+
+ tsParseExpressionStatement(node, expr) {
+ switch (expr.name) {
+ case "declare":
+ {
+ const declaration = this.tsTryParseDeclare(node);
+
+ if (declaration) {
+ declaration.declare = true;
+ return declaration;
+ }
+
+ break;
+ }
+
+ case "global":
+ if (this.match(5)) {
+ this.scope.enter(SCOPE_TS_MODULE);
+ this.prodParam.enter(PARAM);
+ const mod = node;
+ mod.global = true;
+ mod.id = expr;
+ mod.body = this.tsParseModuleBlock();
+ this.scope.exit();
+ this.prodParam.exit();
+ return this.finishNode(mod, "TSModuleDeclaration");
+ }
+
+ break;
+
+ default:
+ return this.tsParseDeclaration(node, expr.name, false);
+ }
+ }
+
+ tsParseDeclaration(node, value, next) {
+ switch (value) {
+ case "abstract":
+ if (this.tsCheckLineTerminator(next) && (this.match(80) || tokenIsIdentifier(this.state.type))) {
+ return this.tsParseAbstractDeclaration(node);
+ }
+
+ break;
+
+ case "enum":
+ if (next || tokenIsIdentifier(this.state.type)) {
+ if (next) this.next();
+ return this.tsParseEnumDeclaration(node, false);
+ }
+
+ break;
+
+ case "interface":
+ if (this.tsCheckLineTerminator(next) && tokenIsIdentifier(this.state.type)) {
+ return this.tsParseInterfaceDeclaration(node);
+ }
+
+ break;
+
+ case "module":
+ if (this.tsCheckLineTerminator(next)) {
+ if (this.match(129)) {
+ return this.tsParseAmbientExternalModuleDeclaration(node);
+ } else if (tokenIsIdentifier(this.state.type)) {
+ return this.tsParseModuleOrNamespaceDeclaration(node);
+ }
+ }
+
+ break;
+
+ case "namespace":
+ if (this.tsCheckLineTerminator(next) && tokenIsIdentifier(this.state.type)) {
+ return this.tsParseModuleOrNamespaceDeclaration(node);
+ }
+
+ break;
+
+ case "type":
+ if (this.tsCheckLineTerminator(next) && tokenIsIdentifier(this.state.type)) {
+ return this.tsParseTypeAliasDeclaration(node);
+ }
+
+ break;
+ }
+ }
+
+ tsCheckLineTerminator(next) {
+ if (next) {
+ if (this.hasFollowingLineBreak()) return false;
+ this.next();
+ return true;
+ }
+
+ return !this.isLineTerminator();
+ }
+
+ tsTryParseGenericAsyncArrowFunction(startPos, startLoc) {
+ if (!this.match(47)) {
+ return undefined;
+ }
+
+ const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;
+ this.state.maybeInArrowParameters = true;
+ const res = this.tsTryParseAndCatch(() => {
+ const node = this.startNodeAt(startPos, startLoc);
+ node.typeParameters = this.tsParseTypeParameters();
+ super.parseFunctionParams(node);
+ node.returnType = this.tsTryParseTypeOrTypePredicateAnnotation();
+ this.expect(19);
+ return node;
+ });
+ this.state.maybeInArrowParameters = oldMaybeInArrowParameters;
+
+ if (!res) {
+ return undefined;
+ }
+
+ return this.parseArrowExpression(res, null, true);
+ }
+
+ tsParseTypeArgumentsInExpression() {
+ if (this.reScan_lt() !== 47) {
+ return undefined;
+ }
+
+ return this.tsParseTypeArguments();
+ }
+
+ tsParseTypeArguments() {
+ const node = this.startNode();
+ node.params = this.tsInType(() => this.tsInNoContext(() => {
+ this.expect(47);
+ return this.tsParseDelimitedList("TypeParametersOrArguments", this.tsParseType.bind(this));
+ }));
+
+ if (node.params.length === 0) {
+ this.raise(TSErrors.EmptyTypeArguments, {
+ node
+ });
+ }
+
+ this.expect(48);
+ return this.finishNode(node, "TSTypeParameterInstantiation");
+ }
+
+ tsIsDeclarationStart() {
+ return tokenIsTSDeclarationStart(this.state.type);
+ }
+
+ isExportDefaultSpecifier() {
+ if (this.tsIsDeclarationStart()) return false;
+ return super.isExportDefaultSpecifier();
+ }
+
+ parseAssignableListItem(allowModifiers, decorators) {
+ const startPos = this.state.start;
+ const startLoc = this.state.startLoc;
+ let accessibility;
+ let readonly = false;
+ let override = false;
+
+ if (allowModifiers !== undefined) {
+ const modified = {};
+ this.tsParseModifiers(modified, ["public", "private", "protected", "override", "readonly"]);
+ accessibility = modified.accessibility;
+ override = modified.override;
+ readonly = modified.readonly;
+
+ if (allowModifiers === false && (accessibility || readonly || override)) {
+ this.raise(TSErrors.UnexpectedParameterModifier, {
+ at: startLoc
+ });
+ }
+ }
+
+ const left = this.parseMaybeDefault();
+ this.parseAssignableListItemTypes(left);
+ const elt = this.parseMaybeDefault(left.start, left.loc.start, left);
+
+ if (accessibility || readonly || override) {
+ const pp = this.startNodeAt(startPos, startLoc);
+
+ if (decorators.length) {
+ pp.decorators = decorators;
+ }
+
+ if (accessibility) pp.accessibility = accessibility;
+ if (readonly) pp.readonly = readonly;
+ if (override) pp.override = override;
+
+ if (elt.type !== "Identifier" && elt.type !== "AssignmentPattern") {
+ this.raise(TSErrors.UnsupportedParameterPropertyKind, {
+ node: pp
+ });
+ }
+
+ pp.parameter = elt;
+ return this.finishNode(pp, "TSParameterProperty");
+ }
+
+ if (decorators.length) {
+ left.decorators = decorators;
+ }
+
+ return elt;
+ }
+
+ parseFunctionBodyAndFinish(node, type, isMethod = false) {
+ if (this.match(14)) {
+ node.returnType = this.tsParseTypeOrTypePredicateAnnotation(14);
+ }
+
+ const bodilessType = type === "FunctionDeclaration" ? "TSDeclareFunction" : type === "ClassMethod" || type === "ClassPrivateMethod" ? "TSDeclareMethod" : undefined;
+
+ if (bodilessType && !this.match(5) && this.isLineTerminator()) {
+ this.finishNode(node, bodilessType);
+ return;
+ }
+
+ if (bodilessType === "TSDeclareFunction" && this.state.isAmbientContext) {
+ this.raise(TSErrors.DeclareFunctionHasImplementation, {
+ node
+ });
+
+ if (node.declare) {
+ super.parseFunctionBodyAndFinish(node, bodilessType, isMethod);
+ return;
+ }
+ }
+
+ super.parseFunctionBodyAndFinish(node, type, isMethod);
+ }
+
+ registerFunctionStatementId(node) {
+ if (!node.body && node.id) {
+ this.checkLVal(node.id, "function name", BIND_TS_AMBIENT);
+ } else {
+ super.registerFunctionStatementId(...arguments);
+ }
+ }
+
+ tsCheckForInvalidTypeCasts(items) {
+ items.forEach(node => {
+ if ((node == null ? void 0 : node.type) === "TSTypeCastExpression") {
+ this.raise(TSErrors.UnexpectedTypeAnnotation, {
+ node: node.typeAnnotation
+ });
+ }
+ });
+ }
+
+ toReferencedList(exprList, isInParens) {
+ this.tsCheckForInvalidTypeCasts(exprList);
+ return exprList;
+ }
+
+ parseArrayLike(...args) {
+ const node = super.parseArrayLike(...args);
+
+ if (node.type === "ArrayExpression") {
+ this.tsCheckForInvalidTypeCasts(node.elements);
+ }
+
+ return node;
+ }
+
+ parseSubscript(base, startPos, startLoc, noCalls, state) {
+ if (!this.hasPrecedingLineBreak() && this.match(35)) {
+ this.state.canStartJSXElement = false;
+ this.next();
+ const nonNullExpression = this.startNodeAt(startPos, startLoc);
+ nonNullExpression.expression = base;
+ return this.finishNode(nonNullExpression, "TSNonNullExpression");
+ }
+
+ let isOptionalCall = false;
+
+ if (this.match(18) && this.lookaheadCharCode() === 60) {
+ if (noCalls) {
+ state.stop = true;
+ return base;
+ }
+
+ state.optionalChainMember = isOptionalCall = true;
+ this.next();
+ }
+
+ if (this.match(47) || this.match(51)) {
+ let missingParenErrorLoc;
+ const result = this.tsTryParseAndCatch(() => {
+ if (!noCalls && this.atPossibleAsyncArrow(base)) {
+ const asyncArrowFn = this.tsTryParseGenericAsyncArrowFunction(startPos, startLoc);
+
+ if (asyncArrowFn) {
+ return asyncArrowFn;
+ }
+ }
+
+ const node = this.startNodeAt(startPos, startLoc);
+ node.callee = base;
+ const typeArguments = this.tsParseTypeArgumentsInExpression();
+
+ if (typeArguments) {
+ if (isOptionalCall && !this.match(10)) {
+ missingParenErrorLoc = this.state.curPosition();
+ this.unexpected();
+ }
+
+ if (!noCalls && this.eat(10)) {
+ node.arguments = this.parseCallExpressionArguments(11, false);
+ this.tsCheckForInvalidTypeCasts(node.arguments);
+ node.typeParameters = typeArguments;
+
+ if (state.optionalChainMember) {
+ node.optional = isOptionalCall;
+ }
+
+ return this.finishCallExpression(node, state.optionalChainMember);
+ } else if (tokenIsTemplate(this.state.type)) {
+ const result = this.parseTaggedTemplateExpression(base, startPos, startLoc, state);
+ result.typeParameters = typeArguments;
+ return result;
+ }
+ }
+
+ this.unexpected();
+ });
+
+ if (missingParenErrorLoc) {
+ this.unexpected(missingParenErrorLoc, 10);
+ }
+
+ if (result) return result;
+ }
+
+ return super.parseSubscript(base, startPos, startLoc, noCalls, state);
+ }
+
+ parseNewArguments(node) {
+ if (this.match(47) || this.match(51)) {
+ const typeParameters = this.tsTryParseAndCatch(() => {
+ const args = this.tsParseTypeArgumentsInExpression();
+ if (!this.match(10)) this.unexpected();
+ return args;
+ });
+
+ if (typeParameters) {
+ node.typeParameters = typeParameters;
+ }
+ }
+
+ super.parseNewArguments(node);
+ }
+
+ parseExprOp(left, leftStartPos, leftStartLoc, minPrec) {
+ if (tokenOperatorPrecedence(58) > minPrec && !this.hasPrecedingLineBreak() && this.isContextual(93)) {
+ const node = this.startNodeAt(leftStartPos, leftStartLoc);
+ node.expression = left;
+
+ const _const = this.tsTryNextParseConstantContext();
+
+ if (_const) {
+ node.typeAnnotation = _const;
+ } else {
+ node.typeAnnotation = this.tsNextThenParseType();
+ }
+
+ this.finishNode(node, "TSAsExpression");
+ this.reScan_lt_gt();
+ return this.parseExprOp(node, leftStartPos, leftStartLoc, minPrec);
+ }
+
+ return super.parseExprOp(left, leftStartPos, leftStartLoc, minPrec);
+ }
+
+ checkReservedWord(word, startLoc, checkKeywords, isBinding) {}
+
+ checkDuplicateExports() {}
+
+ parseImport(node) {
+ node.importKind = "value";
+
+ if (tokenIsIdentifier(this.state.type) || this.match(55) || this.match(5)) {
+ let ahead = this.lookahead();
+
+ if (this.isContextual(126) && ahead.type !== 12 && ahead.type !== 97 && ahead.type !== 29) {
+ node.importKind = "type";
+ this.next();
+ ahead = this.lookahead();
+ }
+
+ if (tokenIsIdentifier(this.state.type) && ahead.type === 29) {
+ return this.tsParseImportEqualsDeclaration(node);
+ }
+ }
+
+ const importNode = super.parseImport(node);
+
+ if (importNode.importKind === "type" && importNode.specifiers.length > 1 && importNode.specifiers[0].type === "ImportDefaultSpecifier") {
+ this.raise(TSErrors.TypeImportCannotSpecifyDefaultAndNamed, {
+ node: importNode
+ });
+ }
+
+ return importNode;
+ }
+
+ parseExport(node) {
+ if (this.match(83)) {
+ this.next();
+
+ if (this.isContextual(126) && this.lookaheadCharCode() !== 61) {
+ node.importKind = "type";
+ this.next();
+ } else {
+ node.importKind = "value";
+ }
+
+ return this.tsParseImportEqualsDeclaration(node, true);
+ } else if (this.eat(29)) {
+ const assign = node;
+ assign.expression = this.parseExpression();
+ this.semicolon();
+ return this.finishNode(assign, "TSExportAssignment");
+ } else if (this.eatContextual(93)) {
+ const decl = node;
+ this.expectContextual(124);
+ decl.id = this.parseIdentifier();
+ this.semicolon();
+ return this.finishNode(decl, "TSNamespaceExportDeclaration");
+ } else {
+ if (this.isContextual(126) && this.lookahead().type === 5) {
+ this.next();
+ node.exportKind = "type";
+ } else {
+ node.exportKind = "value";
+ }
+
+ return super.parseExport(node);
+ }
+ }
+
+ isAbstractClass() {
+ return this.isContextual(120) && this.lookahead().type === 80;
+ }
+
+ parseExportDefaultExpression() {
+ if (this.isAbstractClass()) {
+ const cls = this.startNode();
+ this.next();
+ cls.abstract = true;
+ this.parseClass(cls, true, true);
+ return cls;
+ }
+
+ if (this.match(125)) {
+ const interfaceNode = this.startNode();
+ this.next();
+ const result = this.tsParseInterfaceDeclaration(interfaceNode);
+ if (result) return result;
+ }
+
+ return super.parseExportDefaultExpression();
+ }
+
+ parseStatementContent(context, topLevel) {
+ if (this.state.type === 75) {
+ const ahead = this.lookahead();
+
+ if (ahead.type === 122) {
+ const node = this.startNode();
+ this.next();
+ this.expectContextual(122);
+ return this.tsParseEnumDeclaration(node, true);
+ }
+ }
+
+ return super.parseStatementContent(context, topLevel);
+ }
+
+ parseAccessModifier() {
+ return this.tsParseModifier(["public", "protected", "private"]);
+ }
+
+ tsHasSomeModifiers(member, modifiers) {
+ return modifiers.some(modifier => {
+ if (tsIsAccessModifier(modifier)) {
+ return member.accessibility === modifier;
+ }
+
+ return !!member[modifier];
+ });
+ }
+
+ tsIsStartOfStaticBlocks() {
+ return this.isContextual(104) && this.lookaheadCharCode() === 123;
+ }
+
+ parseClassMember(classBody, member, state) {
+ const modifiers = ["declare", "private", "public", "protected", "override", "abstract", "readonly", "static"];
+ this.tsParseModifiers(member, modifiers, undefined, undefined, true);
+
+ const callParseClassMemberWithIsStatic = () => {
+ if (this.tsIsStartOfStaticBlocks()) {
+ this.next();
+ this.next();
+
+ if (this.tsHasSomeModifiers(member, modifiers)) {
+ this.raise(TSErrors.StaticBlockCannotHaveModifier, {
+ at: this.state.curPosition()
+ });
+ }
+
+ this.parseClassStaticBlock(classBody, member);
+ } else {
+ this.parseClassMemberWithIsStatic(classBody, member, state, !!member.static);
+ }
+ };
+
+ if (member.declare) {
+ this.tsInAmbientContext(callParseClassMemberWithIsStatic);
+ } else {
+ callParseClassMemberWithIsStatic();
+ }
+ }
+
+ parseClassMemberWithIsStatic(classBody, member, state, isStatic) {
+ const idx = this.tsTryParseIndexSignature(member);
+
+ if (idx) {
+ classBody.body.push(idx);
+
+ if (member.abstract) {
+ this.raise(TSErrors.IndexSignatureHasAbstract, {
+ node: member
+ });
+ }
+
+ if (member.accessibility) {
+ this.raise(TSErrors.IndexSignatureHasAccessibility, {
+ node: member
+ }, member.accessibility);
+ }
+
+ if (member.declare) {
+ this.raise(TSErrors.IndexSignatureHasDeclare, {
+ node: member
+ });
+ }
+
+ if (member.override) {
+ this.raise(TSErrors.IndexSignatureHasOverride, {
+ node: member
+ });
+ }
+
+ return;
+ }
+
+ if (!this.state.inAbstractClass && member.abstract) {
+ this.raise(TSErrors.NonAbstractClassHasAbstractMethod, {
+ node: member
+ });
+ }
+
+ if (member.override) {
+ if (!state.hadSuperClass) {
+ this.raise(TSErrors.OverrideNotInSubClass, {
+ node: member
+ });
+ }
+ }
+
+ super.parseClassMemberWithIsStatic(classBody, member, state, isStatic);
+ }
+
+ parsePostMemberNameModifiers(methodOrProp) {
+ const optional = this.eat(17);
+ if (optional) methodOrProp.optional = true;
+
+ if (methodOrProp.readonly && this.match(10)) {
+ this.raise(TSErrors.ClassMethodHasReadonly, {
+ node: methodOrProp
+ });
+ }
+
+ if (methodOrProp.declare && this.match(10)) {
+ this.raise(TSErrors.ClassMethodHasDeclare, {
+ node: methodOrProp
+ });
+ }
+ }
+
+ parseExpressionStatement(node, expr) {
+ const decl = expr.type === "Identifier" ? this.tsParseExpressionStatement(node, expr) : undefined;
+ return decl || super.parseExpressionStatement(node, expr);
+ }
+
+ shouldParseExportDeclaration() {
+ if (this.tsIsDeclarationStart()) return true;
+ return super.shouldParseExportDeclaration();
+ }
+
+ parseConditional(expr, startPos, startLoc, refExpressionErrors) {
+ if (!this.state.maybeInArrowParameters || !this.match(17)) {
+ return super.parseConditional(expr, startPos, startLoc, refExpressionErrors);
+ }
+
+ const result = this.tryParse(() => super.parseConditional(expr, startPos, startLoc));
+
+ if (!result.node) {
+ if (result.error) {
+ super.setOptionalParametersError(refExpressionErrors, result.error);
+ }
+
+ return expr;
+ }
+
+ if (result.error) this.state = result.failState;
+ return result.node;
+ }
+
+ parseParenItem(node, startPos, startLoc) {
+ node = super.parseParenItem(node, startPos, startLoc);
+
+ if (this.eat(17)) {
+ node.optional = true;
+ this.resetEndLocation(node);
+ }
+
+ if (this.match(14)) {
+ const typeCastNode = this.startNodeAt(startPos, startLoc);
+ typeCastNode.expression = node;
+ typeCastNode.typeAnnotation = this.tsParseTypeAnnotation();
+ return this.finishNode(typeCastNode, "TSTypeCastExpression");
+ }
+
+ return node;
+ }
+
+ parseExportDeclaration(node) {
+ const startPos = this.state.start;
+ const startLoc = this.state.startLoc;
+ const isDeclare = this.eatContextual(121);
+
+ if (isDeclare && (this.isContextual(121) || !this.shouldParseExportDeclaration())) {
+ throw this.raise(TSErrors.ExpectedAmbientAfterExportDeclare, {
+ at: this.state.startLoc
+ });
+ }
+
+ let declaration;
+
+ if (tokenIsIdentifier(this.state.type)) {
+ declaration = this.tsTryParseExportDeclaration();
+ }
+
+ if (!declaration) {
+ declaration = super.parseExportDeclaration(node);
+ }
+
+ if (declaration && (declaration.type === "TSInterfaceDeclaration" || declaration.type === "TSTypeAliasDeclaration" || isDeclare)) {
+ node.exportKind = "type";
+ }
+
+ if (declaration && isDeclare) {
+ this.resetStartLocation(declaration, startPos, startLoc);
+ declaration.declare = true;
+ }
+
+ return declaration;
+ }
+
+ parseClassId(node, isStatement, optionalId) {
+ if ((!isStatement || optionalId) && this.isContextual(110)) {
+ return;
+ }
+
+ super.parseClassId(node, isStatement, optionalId, node.declare ? BIND_TS_AMBIENT : BIND_CLASS);
+ const typeParameters = this.tsTryParseTypeParameters();
+ if (typeParameters) node.typeParameters = typeParameters;
+ }
+
+ parseClassPropertyAnnotation(node) {
+ if (!node.optional && this.eat(35)) {
+ node.definite = true;
+ }
+
+ const type = this.tsTryParseTypeAnnotation();
+ if (type) node.typeAnnotation = type;
+ }
+
+ parseClassProperty(node) {
+ this.parseClassPropertyAnnotation(node);
+
+ if (this.state.isAmbientContext && this.match(29)) {
+ this.raise(TSErrors.DeclareClassFieldHasInitializer, {
+ at: this.state.startLoc
+ });
+ }
+
+ if (node.abstract && this.match(29)) {
+ const {
+ key
+ } = node;
+ this.raise(TSErrors.AbstractPropertyHasInitializer, {
+ at: this.state.startLoc
+ }, key.type === "Identifier" && !node.computed ? key.name : `[${this.input.slice(key.start, key.end)}]`);
+ }
+
+ return super.parseClassProperty(node);
+ }
+
+ parseClassPrivateProperty(node) {
+ if (node.abstract) {
+ this.raise(TSErrors.PrivateElementHasAbstract, {
+ node
+ });
+ }
+
+ if (node.accessibility) {
+ this.raise(TSErrors.PrivateElementHasAccessibility, {
+ node
+ }, node.accessibility);
+ }
+
+ this.parseClassPropertyAnnotation(node);
+ return super.parseClassPrivateProperty(node);
+ }
+
+ pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) {
+ const typeParameters = this.tsTryParseTypeParameters();
+
+ if (typeParameters && isConstructor) {
+ this.raise(TSErrors.ConstructorHasTypeParameters, {
+ node: typeParameters
+ });
+ }
+
+ if (method.declare && (method.kind === "get" || method.kind === "set")) {
+ this.raise(TSErrors.DeclareAccessor, {
+ node: method
+ }, method.kind);
+ }
+
+ if (typeParameters) method.typeParameters = typeParameters;
+ super.pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper);
+ }
+
+ pushClassPrivateMethod(classBody, method, isGenerator, isAsync) {
+ const typeParameters = this.tsTryParseTypeParameters();
+ if (typeParameters) method.typeParameters = typeParameters;
+ super.pushClassPrivateMethod(classBody, method, isGenerator, isAsync);
+ }
+
+ declareClassPrivateMethodInScope(node, kind) {
+ if (node.type === "TSDeclareMethod") return;
+ if (node.type === "MethodDefinition" && !node.value.body) return;
+ super.declareClassPrivateMethodInScope(node, kind);
+ }
+
+ parseClassSuper(node) {
+ super.parseClassSuper(node);
+
+ if (node.superClass && (this.match(47) || this.match(51))) {
+ node.superTypeParameters = this.tsParseTypeArgumentsInExpression();
+ }
+
+ if (this.eatContextual(110)) {
+ node.implements = this.tsParseHeritageClause("implements");
+ }
+ }
+
+ parseObjPropValue(prop, ...args) {
+ const typeParameters = this.tsTryParseTypeParameters();
+ if (typeParameters) prop.typeParameters = typeParameters;
+ super.parseObjPropValue(prop, ...args);
+ }
+
+ parseFunctionParams(node, allowModifiers) {
+ const typeParameters = this.tsTryParseTypeParameters();
+ if (typeParameters) node.typeParameters = typeParameters;
+ super.parseFunctionParams(node, allowModifiers);
+ }
+
+ parseVarId(decl, kind) {
+ super.parseVarId(decl, kind);
+
+ if (decl.id.type === "Identifier" && !this.hasPrecedingLineBreak() && this.eat(35)) {
+ decl.definite = true;
+ }
+
+ const type = this.tsTryParseTypeAnnotation();
+
+ if (type) {
+ decl.id.typeAnnotation = type;
+ this.resetEndLocation(decl.id);
+ }
+ }
+
+ parseAsyncArrowFromCallExpression(node, call) {
+ if (this.match(14)) {
+ node.returnType = this.tsParseTypeAnnotation();
+ }
+
+ return super.parseAsyncArrowFromCallExpression(node, call);
+ }
+
+ parseMaybeAssign(...args) {
+ var _jsx, _jsx2, _typeCast, _jsx3, _typeCast2, _jsx4, _typeCast3;
+
+ let state;
+ let jsx;
+ let typeCast;
+
+ if (this.hasPlugin("jsx") && (this.match(138) || this.match(47))) {
+ state = this.state.clone();
+ jsx = this.tryParse(() => super.parseMaybeAssign(...args), state);
+ if (!jsx.error) return jsx.node;
+ const {
+ context
+ } = this.state;
+ const currentContext = context[context.length - 1];
+
+ if (currentContext === types.j_oTag || currentContext === types.j_expr) {
+ context.pop();
+ }
+ }
+
+ if (!((_jsx = jsx) != null && _jsx.error) && !this.match(47)) {
+ return super.parseMaybeAssign(...args);
+ }
+
+ let typeParameters;
+ state = state || this.state.clone();
+ const arrow = this.tryParse(abort => {
+ var _expr$extra, _typeParameters;
+
+ typeParameters = this.tsParseTypeParameters();
+ const expr = super.parseMaybeAssign(...args);
+
+ if (expr.type !== "ArrowFunctionExpression" || (_expr$extra = expr.extra) != null && _expr$extra.parenthesized) {
+ abort();
+ }
+
+ if (((_typeParameters = typeParameters) == null ? void 0 : _typeParameters.params.length) !== 0) {
+ this.resetStartLocationFromNode(expr, typeParameters);
+ }
+
+ expr.typeParameters = typeParameters;
+ return expr;
+ }, state);
+
+ if (!arrow.error && !arrow.aborted) {
+ if (typeParameters) this.reportReservedArrowTypeParam(typeParameters);
+ return arrow.node;
+ }
+
+ if (!jsx) {
+ assert(!this.hasPlugin("jsx"));
+ typeCast = this.tryParse(() => super.parseMaybeAssign(...args), state);
+ if (!typeCast.error) return typeCast.node;
+ }
+
+ if ((_jsx2 = jsx) != null && _jsx2.node) {
+ this.state = jsx.failState;
+ return jsx.node;
+ }
+
+ if (arrow.node) {
+ this.state = arrow.failState;
+ if (typeParameters) this.reportReservedArrowTypeParam(typeParameters);
+ return arrow.node;
+ }
+
+ if ((_typeCast = typeCast) != null && _typeCast.node) {
+ this.state = typeCast.failState;
+ return typeCast.node;
+ }
+
+ if ((_jsx3 = jsx) != null && _jsx3.thrown) throw jsx.error;
+ if (arrow.thrown) throw arrow.error;
+ if ((_typeCast2 = typeCast) != null && _typeCast2.thrown) throw typeCast.error;
+ throw ((_jsx4 = jsx) == null ? void 0 : _jsx4.error) || arrow.error || ((_typeCast3 = typeCast) == null ? void 0 : _typeCast3.error);
+ }
+
+ reportReservedArrowTypeParam(node) {
+ var _node$extra;
+
+ if (node.params.length === 1 && !((_node$extra = node.extra) != null && _node$extra.trailingComma) && this.getPluginOption("typescript", "disallowAmbiguousJSXLike")) {
+ this.raise(TSErrors.ReservedArrowTypeParam, {
+ node
+ });
+ }
+ }
+
+ parseMaybeUnary(refExpressionErrors) {
+ if (!this.hasPlugin("jsx") && this.match(47)) {
+ return this.tsParseTypeAssertion();
+ } else {
+ return super.parseMaybeUnary(refExpressionErrors);
+ }
+ }
+
+ parseArrow(node) {
+ if (this.match(14)) {
+ const result = this.tryParse(abort => {
+ const returnType = this.tsParseTypeOrTypePredicateAnnotation(14);
+ if (this.canInsertSemicolon() || !this.match(19)) abort();
+ return returnType;
+ });
+ if (result.aborted) return;
+
+ if (!result.thrown) {
+ if (result.error) this.state = result.failState;
+ node.returnType = result.node;
+ }
+ }
+
+ return super.parseArrow(node);
+ }
+
+ parseAssignableListItemTypes(param) {
+ if (this.eat(17)) {
+ if (param.type !== "Identifier" && !this.state.isAmbientContext && !this.state.inType) {
+ this.raise(TSErrors.PatternIsOptional, {
+ node: param
+ });
+ }
+
+ param.optional = true;
+ }
+
+ const type = this.tsTryParseTypeAnnotation();
+ if (type) param.typeAnnotation = type;
+ this.resetEndLocation(param);
+ return param;
+ }
+
+ isAssignable(node, isBinding) {
+ switch (node.type) {
+ case "TSTypeCastExpression":
+ return this.isAssignable(node.expression, isBinding);
+
+ case "TSParameterProperty":
+ return true;
+
+ default:
+ return super.isAssignable(node, isBinding);
+ }
+ }
+
+ toAssignable(node, isLHS = false) {
+ switch (node.type) {
+ case "TSTypeCastExpression":
+ return super.toAssignable(this.typeCastToParameter(node), isLHS);
+
+ case "TSParameterProperty":
+ return super.toAssignable(node, isLHS);
+
+ case "ParenthesizedExpression":
+ return this.toAssignableParenthesizedExpression(node, isLHS);
+
+ case "TSAsExpression":
+ case "TSNonNullExpression":
+ case "TSTypeAssertion":
+ node.expression = this.toAssignable(node.expression, isLHS);
+ return node;
+
+ default:
+ return super.toAssignable(node, isLHS);
+ }
+ }
+
+ toAssignableParenthesizedExpression(node, isLHS) {
+ switch (node.expression.type) {
+ case "TSAsExpression":
+ case "TSNonNullExpression":
+ case "TSTypeAssertion":
+ case "ParenthesizedExpression":
+ node.expression = this.toAssignable(node.expression, isLHS);
+ return node;
+
+ default:
+ return super.toAssignable(node, isLHS);
+ }
+ }
+
+ checkLVal(expr, contextDescription, ...args) {
+ var _expr$extra2;
+
+ switch (expr.type) {
+ case "TSTypeCastExpression":
+ return;
+
+ case "TSParameterProperty":
+ this.checkLVal(expr.parameter, "parameter property", ...args);
+ return;
+
+ case "TSAsExpression":
+ case "TSTypeAssertion":
+ if (!args[0] && contextDescription !== "parenthesized expression" && !((_expr$extra2 = expr.extra) != null && _expr$extra2.parenthesized)) {
+ this.raise(ErrorMessages.InvalidLhs, {
+ node: expr
+ }, contextDescription);
+ break;
+ }
+
+ this.checkLVal(expr.expression, "parenthesized expression", ...args);
+ return;
+
+ case "TSNonNullExpression":
+ this.checkLVal(expr.expression, contextDescription, ...args);
+ return;
+
+ default:
+ super.checkLVal(expr, contextDescription, ...args);
+ return;
+ }
+ }
+
+ parseBindingAtom() {
+ switch (this.state.type) {
+ case 78:
+ return this.parseIdentifier(true);
+
+ default:
+ return super.parseBindingAtom();
+ }
+ }
+
+ parseMaybeDecoratorArguments(expr) {
+ if (this.match(47) || this.match(51)) {
+ const typeArguments = this.tsParseTypeArgumentsInExpression();
+
+ if (this.match(10)) {
+ const call = super.parseMaybeDecoratorArguments(expr);
+ call.typeParameters = typeArguments;
+ return call;
+ }
+
+ this.unexpected(null, 10);
+ }
+
+ return super.parseMaybeDecoratorArguments(expr);
+ }
+
+ checkCommaAfterRest(close) {
+ if (this.state.isAmbientContext && this.match(12) && this.lookaheadCharCode() === close) {
+ this.next();
+ return false;
+ } else {
+ return super.checkCommaAfterRest(close);
+ }
+ }
+
+ isClassMethod() {
+ return this.match(47) || super.isClassMethod();
+ }
+
+ isClassProperty() {
+ return this.match(35) || this.match(14) || super.isClassProperty();
+ }
+
+ parseMaybeDefault(...args) {
+ const node = super.parseMaybeDefault(...args);
+
+ if (node.type === "AssignmentPattern" && node.typeAnnotation && node.right.start < node.typeAnnotation.start) {
+ this.raise(TSErrors.TypeAnnotationAfterAssign, {
+ node: node.typeAnnotation
+ });
+ }
+
+ return node;
+ }
+
+ getTokenFromCode(code) {
+ if (this.state.inType) {
+ if (code === 62) {
+ return this.finishOp(48, 1);
+ }
+
+ if (code === 60) {
+ return this.finishOp(47, 1);
+ }
+ }
+
+ return super.getTokenFromCode(code);
+ }
+
+ reScan_lt_gt() {
+ const {
+ type
+ } = this.state;
+
+ if (type === 47) {
+ this.state.pos -= 1;
+ this.readToken_lt();
+ } else if (type === 48) {
+ this.state.pos -= 1;
+ this.readToken_gt();
+ }
+ }
+
+ reScan_lt() {
+ const {
+ type
+ } = this.state;
+
+ if (type === 51) {
+ this.state.pos -= 2;
+ this.finishOp(47, 1);
+ return 47;
+ }
+
+ return type;
+ }
+
+ toAssignableList(exprList) {
+ for (let i = 0; i < exprList.length; i++) {
+ const expr = exprList[i];
+ if (!expr) continue;
+
+ switch (expr.type) {
+ case "TSTypeCastExpression":
+ exprList[i] = this.typeCastToParameter(expr);
+ break;
+
+ case "TSAsExpression":
+ case "TSTypeAssertion":
+ if (!this.state.maybeInArrowParameters) {
+ exprList[i] = this.typeCastToParameter(expr);
+ } else {
+ this.raise(TSErrors.UnexpectedTypeCastInParameter, {
+ node: expr
+ });
+ }
+
+ break;
+ }
+ }
+
+ return super.toAssignableList(...arguments);
+ }
+
+ typeCastToParameter(node) {
+ node.expression.typeAnnotation = node.typeAnnotation;
+ this.resetEndLocation(node.expression, node.typeAnnotation.loc.end);
+ return node.expression;
+ }
+
+ shouldParseArrow(params) {
+ if (this.match(14)) {
+ return params.every(expr => this.isAssignable(expr, true));
+ }
+
+ return super.shouldParseArrow(params);
+ }
+
+ shouldParseAsyncArrow() {
+ return this.match(14) || super.shouldParseAsyncArrow();
+ }
+
+ canHaveLeadingDecorator() {
+ return super.canHaveLeadingDecorator() || this.isAbstractClass();
+ }
+
+ jsxParseOpeningElementAfterName(node) {
+ if (this.match(47) || this.match(51)) {
+ const typeArguments = this.tsTryParseAndCatch(() => this.tsParseTypeArgumentsInExpression());
+ if (typeArguments) node.typeParameters = typeArguments;
+ }
+
+ return super.jsxParseOpeningElementAfterName(node);
+ }
+
+ getGetterSetterExpectedParamCount(method) {
+ const baseCount = super.getGetterSetterExpectedParamCount(method);
+ const params = this.getObjectOrClassMethodParams(method);
+ const firstParam = params[0];
+ const hasContextParam = firstParam && this.isThisParam(firstParam);
+ return hasContextParam ? baseCount + 1 : baseCount;
+ }
+
+ parseCatchClauseParam() {
+ const param = super.parseCatchClauseParam();
+ const type = this.tsTryParseTypeAnnotation();
+
+ if (type) {
+ param.typeAnnotation = type;
+ this.resetEndLocation(param);
+ }
+
+ return param;
+ }
+
+ tsInAmbientContext(cb) {
+ const oldIsAmbientContext = this.state.isAmbientContext;
+ this.state.isAmbientContext = true;
+
+ try {
+ return cb();
+ } finally {
+ this.state.isAmbientContext = oldIsAmbientContext;
+ }
+ }
+
+ parseClass(node, ...args) {
+ const oldInAbstractClass = this.state.inAbstractClass;
+ this.state.inAbstractClass = !!node.abstract;
+
+ try {
+ return super.parseClass(node, ...args);
+ } finally {
+ this.state.inAbstractClass = oldInAbstractClass;
+ }
+ }
+
+ tsParseAbstractDeclaration(node) {
+ if (this.match(80)) {
+ node.abstract = true;
+ return this.parseClass(node, true, false);
+ } else if (this.isContextual(125)) {
+ if (!this.hasFollowingLineBreak()) {
+ node.abstract = true;
+ this.raise(TSErrors.NonClassMethodPropertyHasAbstractModifer, {
+ node
+ });
+ this.next();
+ return this.tsParseInterfaceDeclaration(node);
+ }
+ } else {
+ this.unexpected(null, 80);
+ }
+ }
+
+ parseMethod(...args) {
+ const method = super.parseMethod(...args);
+
+ if (method.abstract) {
+ const hasBody = this.hasPlugin("estree") ? !!method.value.body : !!method.body;
+
+ if (hasBody) {
+ const {
+ key
+ } = method;
+ this.raise(TSErrors.AbstractMethodHasImplementation, {
+ node: method
+ }, key.type === "Identifier" && !method.computed ? key.name : `[${this.input.slice(key.start, key.end)}]`);
+ }
+ }
+
+ return method;
+ }
+
+ tsParseTypeParameterName() {
+ const typeName = this.parseIdentifier();
+ return typeName.name;
+ }
+
+ shouldParseAsAmbientContext() {
+ return !!this.getPluginOption("typescript", "dts");
+ }
+
+ parse() {
+ if (this.shouldParseAsAmbientContext()) {
+ this.state.isAmbientContext = true;
+ }
+
+ return super.parse();
+ }
+
+ getExpression() {
+ if (this.shouldParseAsAmbientContext()) {
+ this.state.isAmbientContext = true;
+ }
+
+ return super.getExpression();
+ }
+
+ parseExportSpecifier(node, isString, isInTypeExport, isMaybeTypeOnly) {
+ if (!isString && isMaybeTypeOnly) {
+ this.parseTypeOnlyImportExportSpecifier(node, false, isInTypeExport);
+ return this.finishNode(node, "ExportSpecifier");
+ }
+
+ node.exportKind = "value";
+ return super.parseExportSpecifier(node, isString, isInTypeExport, isMaybeTypeOnly);
+ }
+
+ parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly) {
+ if (!importedIsString && isMaybeTypeOnly) {
+ this.parseTypeOnlyImportExportSpecifier(specifier, true, isInTypeOnlyImport);
+ return this.finishNode(specifier, "ImportSpecifier");
+ }
+
+ specifier.importKind = "value";
+ return super.parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly);
+ }
+
+ parseTypeOnlyImportExportSpecifier(node, isImport, isInTypeOnlyImportExport) {
+ const leftOfAsKey = isImport ? "imported" : "local";
+ const rightOfAsKey = isImport ? "local" : "exported";
+ let leftOfAs = node[leftOfAsKey];
+ let rightOfAs;
+ let hasTypeSpecifier = false;
+ let canParseAsKeyword = true;
+ const loc = leftOfAs.loc.start;
+
+ if (this.isContextual(93)) {
+ const firstAs = this.parseIdentifier();
+
+ if (this.isContextual(93)) {
+ const secondAs = this.parseIdentifier();
+
+ if (tokenIsKeywordOrIdentifier(this.state.type)) {
+ hasTypeSpecifier = true;
+ leftOfAs = firstAs;
+ rightOfAs = this.parseIdentifier();
+ canParseAsKeyword = false;
+ } else {
+ rightOfAs = secondAs;
+ canParseAsKeyword = false;
+ }
+ } else if (tokenIsKeywordOrIdentifier(this.state.type)) {
+ canParseAsKeyword = false;
+ rightOfAs = this.parseIdentifier();
+ } else {
+ hasTypeSpecifier = true;
+ leftOfAs = firstAs;
+ }
+ } else if (tokenIsKeywordOrIdentifier(this.state.type)) {
+ hasTypeSpecifier = true;
+ leftOfAs = this.parseIdentifier();
+ }
+
+ if (hasTypeSpecifier && isInTypeOnlyImportExport) {
+ this.raise(isImport ? TSErrors.TypeModifierIsUsedInTypeImports : TSErrors.TypeModifierIsUsedInTypeExports, {
+ at: loc
+ });
+ }
+
+ node[leftOfAsKey] = leftOfAs;
+ node[rightOfAsKey] = rightOfAs;
+ const kindKey = isImport ? "importKind" : "exportKind";
+ node[kindKey] = hasTypeSpecifier ? "type" : "value";
+
+ if (canParseAsKeyword && this.eatContextual(93)) {
+ node[rightOfAsKey] = isImport ? this.parseIdentifier() : this.parseModuleExportName();
+ }
+
+ if (!node[rightOfAsKey]) {
+ node[rightOfAsKey] = cloneIdentifier(node[leftOfAsKey]);
+ }
+
+ if (isImport) {
+ this.checkLVal(node[rightOfAsKey], "import specifier", BIND_LEXICAL);
+ }
+ }
+
+});
+
+const PlaceholderErrors = makeErrorTemplates({
+ ClassNameIsRequired: "A class name is required."
+}, ErrorCodes.SyntaxError, "placeholders");
+var placeholders = (superClass => class extends superClass {
+ parsePlaceholder(expectedNode) {
+ if (this.match(140)) {
+ 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(140);
+ 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(140, 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);
+ }
+
+ isLet(context) {
+ if (super.isLet(context)) {
+ return true;
+ }
+
+ if (!this.isContextual(99)) {
+ return false;
+ }
+
+ if (context) return false;
+ const nextToken = this.lookahead();
+
+ if (nextToken.type === 140) {
+ return true;
+ }
+
+ return false;
+ }
+
+ 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(14)) {
+ 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(81) || this.match(140) || this.match(5)) {
+ node.id = placeholder;
+ } else if (optionalId || !isStatement) {
+ node.id = null;
+ node.body = this.finishPlaceholder(placeholder, "ClassBody");
+ return this.finishNode(node, type);
+ } else {
+ throw this.raise(PlaceholderErrors.ClassNameIsRequired, {
+ at: this.state.startLoc
+ });
+ }
+ } 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(97) && !this.match(12)) {
+ 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(65)) {
+ const next = this.nextTokenStart();
+
+ if (this.isUnparsedContextual(next, "from")) {
+ if (this.input.startsWith(tokenLabelName(140), 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 != null && 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(97) && !this.match(12)) {
+ 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(12)) {
+ const hasStarImport = this.maybeParseStarImportSpecifier(node);
+ if (!hasStarImport) this.parseNamedImportSpecifiers(node);
+ }
+
+ this.expectContextual(97);
+ node.source = this.parseImportSource();
+ this.semicolon();
+ return this.finishNode(node, "ImportDeclaration");
+ }
+
+ parseImportSource() {
+ return this.parsePlaceholder("StringLiteral") || super.parseImportSource(...arguments);
+ }
+
+});
+
+var v8intrinsic = (superClass => class extends superClass {
+ parseV8Intrinsic() {
+ if (this.match(54)) {
+ const v8IntrinsicStartLoc = this.state.startLoc;
+ const node = this.startNode();
+ this.next();
+
+ if (tokenIsIdentifier(this.state.type)) {
+ const name = this.parseIdentifierName(this.state.start);
+ const identifier = this.createIdentifier(node, name);
+ identifier.type = "V8IntrinsicIdentifier";
+
+ if (this.match(10)) {
+ return identifier;
+ }
+ }
+
+ this.unexpected(v8IntrinsicStartLoc);
+ }
+ }
+
+ parseExprAtom() {
+ return this.parseV8Intrinsic() || super.parseExprAtom(...arguments);
+ }
+
+});
+
+function hasPlugin(plugins, expectedConfig) {
+ const [expectedName, expectedOptions] = typeof expectedConfig === "string" ? [expectedConfig, {}] : expectedConfig;
+ const expectedKeys = Object.keys(expectedOptions);
+ const expectedOptionsIsEmpty = expectedKeys.length === 0;
+ return plugins.some(p => {
+ if (typeof p === "string") {
+ return expectedOptionsIsEmpty && p === expectedName;
+ } else {
+ const [pluginName, pluginOptions] = p;
+
+ if (pluginName !== expectedName) {
+ return false;
+ }
+
+ for (const key of expectedKeys) {
+ if (pluginOptions[key] !== expectedOptions[key]) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+ });
+}
+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", "fsharp", "hack", "smart"];
+const TOPIC_TOKENS = ["^^", "@@", "^", "%", "#"];
+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")) {
+ const proposal = getPluginOption(plugins, "pipelineOperator", "proposal");
+
+ if (!PIPELINE_PROPOSALS.includes(proposal)) {
+ const proposalList = PIPELINE_PROPOSALS.map(p => `"${p}"`).join(", ");
+ throw new Error(`"pipelineOperator" requires "proposal" option whose value must be one of: ${proposalList}.`);
+ }
+
+ const tupleSyntaxIsHash = hasPlugin(plugins, ["recordAndTuple", {
+ syntaxType: "hash"
+ }]);
+
+ if (proposal === "hack") {
+ if (hasPlugin(plugins, "placeholders")) {
+ throw new Error("Cannot combine placeholders plugin and Hack-style pipes.");
+ }
+
+ if (hasPlugin(plugins, "v8intrinsic")) {
+ throw new Error("Cannot combine v8intrinsic plugin and Hack-style pipes.");
+ }
+
+ const topicToken = getPluginOption(plugins, "pipelineOperator", "topicToken");
+
+ if (!TOPIC_TOKENS.includes(topicToken)) {
+ const tokenList = TOPIC_TOKENS.map(t => `"${t}"`).join(", ");
+ throw new Error(`"pipelineOperator" in "proposal": "hack" mode also requires a "topicToken" option whose value must be one of: ${tokenList}.`);
+ }
+
+ if (topicToken === "#" && tupleSyntaxIsHash) {
+ throw new Error('Plugin conflict between `["pipelineOperator", { proposal: "hack", topicToken: "#" }]` and `["recordAndtuple", { syntaxType: "hash"}]`.');
+ }
+ } else if (proposal === "smart" && tupleSyntaxIsHash) {
+ throw new Error('Plugin conflict between `["pipelineOperator", { proposal: "smart" }]` and `["recordAndtuple", { syntaxType: "hash"}]`.');
+ }
+ }
+
+ 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(", "));
+ }
+
+ if (hasPlugin(plugins, "asyncDoExpressions") && !hasPlugin(plugins, "doExpressions")) {
+ const error = new Error("'asyncDoExpressions' requires 'doExpressions', please add 'doExpressions' to parser plugins.");
+ error.missingPlugins = "doExpressions";
+ throw error;
+ }
+}
+const mixinPlugins = {
+ estree,
+ jsx,
+ flow,
+ typescript,
+ v8intrinsic,
+ placeholders
+};
+const mixinPluginNames = Object.keys(mixinPlugins);
+
+const defaultOptions = {
+ sourceType: "script",
+ sourceFilename: undefined,
+ startColumn: 0,
+ startLine: 1,
+ allowAwaitOutsideFunction: false,
+ allowReturnOutsideFunction: false,
+ allowImportExportEverywhere: false,
+ allowSuperOutsideMethod: false,
+ allowUndeclaredExports: false,
+ plugins: [],
+ strictMode: null,
+ ranges: false,
+ tokens: false,
+ createParenthesizedExpressions: false,
+ errorRecovery: false,
+ attachComment: true
+};
+function getOptions(opts) {
+ const options = {};
+
+ for (const key of Object.keys(defaultOptions)) {
+ options[key] = opts && opts[key] != null ? opts[key] : defaultOptions[key];
+ }
+
+ return options;
+}
+
+const unwrapParenthesizedExpression = node => {
+ return node.type === "ParenthesizedExpression" ? unwrapParenthesizedExpression(node.expression) : node;
+};
+
+class LValParser extends NodeUtils {
+ toAssignable(node, isLHS = false) {
+ var _node$extra, _node$extra3;
+
+ let parenthesized = undefined;
+
+ if (node.type === "ParenthesizedExpression" || (_node$extra = node.extra) != null && _node$extra.parenthesized) {
+ parenthesized = unwrapParenthesizedExpression(node);
+
+ if (isLHS) {
+ if (parenthesized.type === "Identifier") {
+ this.expressionScope.recordParenthesizedIdentifierError(ErrorMessages.InvalidParenthesizedAssignment, node.loc.start);
+ } else if (parenthesized.type !== "MemberExpression") {
+ this.raise(ErrorMessages.InvalidParenthesizedAssignment, {
+ node
+ });
+ }
+ } else {
+ this.raise(ErrorMessages.InvalidParenthesizedAssignment, {
+ node
+ });
+ }
+ }
+
+ switch (node.type) {
+ case "Identifier":
+ case "ObjectPattern":
+ case "ArrayPattern":
+ case "AssignmentPattern":
+ case "RestElement":
+ break;
+
+ case "ObjectExpression":
+ node.type = "ObjectPattern";
+
+ for (let i = 0, length = node.properties.length, last = length - 1; i < length; i++) {
+ var _node$extra2;
+
+ const prop = node.properties[i];
+ const isLast = i === last;
+ this.toAssignableObjectExpressionProp(prop, isLast, isLHS);
+
+ if (isLast && prop.type === "RestElement" && (_node$extra2 = node.extra) != null && _node$extra2.trailingCommaLoc) {
+ this.raise(ErrorMessages.RestTrailingComma, {
+ at: node.extra.trailingCommaLoc
+ });
+ }
+ }
+
+ break;
+
+ case "ObjectProperty":
+ {
+ const {
+ key,
+ value
+ } = node;
+
+ if (this.isPrivateName(key)) {
+ this.classScope.usePrivateName(this.getPrivateNameSV(key), key.loc.start);
+ }
+
+ this.toAssignable(value, isLHS);
+ break;
+ }
+
+ case "SpreadElement":
+ {
+ this.checkToRestConversion(node);
+ node.type = "RestElement";
+ const arg = node.argument;
+ this.toAssignable(arg, isLHS);
+ break;
+ }
+
+ case "ArrayExpression":
+ node.type = "ArrayPattern";
+ this.toAssignableList(node.elements, (_node$extra3 = node.extra) == null ? void 0 : _node$extra3.trailingCommaLoc, isLHS);
+ break;
+
+ case "AssignmentExpression":
+ if (node.operator !== "=") {
+ this.raise(ErrorMessages.MissingEqInAssignment, {
+ at: node.left.loc.end
+ });
+ }
+
+ node.type = "AssignmentPattern";
+ delete node.operator;
+ this.toAssignable(node.left, isLHS);
+ break;
+
+ case "ParenthesizedExpression":
+ this.toAssignable(parenthesized, isLHS);
+ break;
+ }
+
+ return node;
+ }
+
+ toAssignableObjectExpressionProp(prop, isLast, isLHS) {
+ if (prop.type === "ObjectMethod") {
+ this.raise(prop.kind === "get" || prop.kind === "set" ? ErrorMessages.PatternHasAccessor : ErrorMessages.PatternHasMethod, {
+ node: prop.key
+ });
+ } else if (prop.type === "SpreadElement" && !isLast) {
+ this.raise(ErrorMessages.RestTrailingComma, {
+ node: prop
+ });
+ } else {
+ this.toAssignable(prop, isLHS);
+ }
+ }
+
+ toAssignableList(exprList, trailingCommaLoc, isLHS) {
+ let end = exprList.length;
+
+ if (end) {
+ const last = exprList[end - 1];
+
+ if ((last == null ? void 0 : last.type) === "RestElement") {
+ --end;
+ } else if ((last == null ? void 0 : last.type) === "SpreadElement") {
+ last.type = "RestElement";
+ let arg = last.argument;
+ this.toAssignable(arg, isLHS);
+ arg = unwrapParenthesizedExpression(arg);
+
+ if (arg.type !== "Identifier" && arg.type !== "MemberExpression" && arg.type !== "ArrayPattern" && arg.type !== "ObjectPattern") {
+ this.unexpected(arg.start);
+ }
+
+ if (trailingCommaLoc) {
+ this.raise(ErrorMessages.RestTrailingComma, {
+ at: trailingCommaLoc
+ });
+ }
+
+ --end;
+ }
+ }
+
+ for (let i = 0; i < end; i++) {
+ const elt = exprList[i];
+
+ if (elt) {
+ this.toAssignable(elt, isLHS);
+
+ if (elt.type === "RestElement") {
+ this.raise(ErrorMessages.RestTrailingComma, {
+ node: elt
+ });
+ }
+ }
+ }
+
+ return exprList;
+ }
+
+ isAssignable(node, isBinding) {
+ switch (node.type) {
+ case "Identifier":
+ case "ObjectPattern":
+ case "ArrayPattern":
+ case "AssignmentPattern":
+ case "RestElement":
+ return true;
+
+ case "ObjectExpression":
+ {
+ const last = node.properties.length - 1;
+ return node.properties.every((prop, i) => {
+ return prop.type !== "ObjectMethod" && (i === last || prop.type !== "SpreadElement") && this.isAssignable(prop);
+ });
+ }
+
+ case "ObjectProperty":
+ return this.isAssignable(node.value);
+
+ case "SpreadElement":
+ return this.isAssignable(node.argument);
+
+ case "ArrayExpression":
+ return node.elements.every(element => element === null || this.isAssignable(element));
+
+ case "AssignmentExpression":
+ return node.operator === "=";
+
+ case "ParenthesizedExpression":
+ return this.isAssignable(node.expression);
+
+ case "MemberExpression":
+ case "OptionalMemberExpression":
+ return !isBinding;
+
+ default:
+ return false;
+ }
+ }
+
+ toReferencedList(exprList, isParenthesizedExpr) {
+ return exprList;
+ }
+
+ toReferencedListDeep(exprList, isParenthesizedExpr) {
+ this.toReferencedList(exprList, isParenthesizedExpr);
+
+ for (const expr of exprList) {
+ if ((expr == null ? void 0 : 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 0:
+ {
+ const node = this.startNode();
+ this.next();
+ node.elements = this.parseBindingList(3, 93, true);
+ return this.finishNode(node, "ArrayPattern");
+ }
+
+ case 5:
+ return this.parseObjectLike(8, 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(12);
+ }
+
+ if (allowEmpty && this.match(12)) {
+ elts.push(null);
+ } else if (this.eat(close)) {
+ break;
+ } else if (this.match(21)) {
+ elts.push(this.parseAssignableListItemTypes(this.parseRestBinding()));
+
+ if (!this.checkCommaAfterRest(closeCharCode)) {
+ this.expect(close);
+ break;
+ }
+ } else {
+ const decorators = [];
+
+ if (this.match(26) && this.hasPlugin("decorators")) {
+ this.raise(ErrorMessages.UnsupportedParameterDecorator, {
+ at: this.state.startLoc
+ });
+ }
+
+ while (this.match(26)) {
+ decorators.push(this.parseDecorator());
+ }
+
+ elts.push(this.parseAssignableListItem(allowModifiers, decorators));
+ }
+ }
+
+ return elts;
+ }
+
+ parseBindingRestProperty(prop) {
+ this.next();
+ prop.argument = this.parseIdentifier();
+ this.checkCommaAfterRest(125);
+ return this.finishNode(prop, "RestElement");
+ }
+
+ parseBindingProperty() {
+ const prop = this.startNode();
+ const {
+ type,
+ start: startPos,
+ startLoc
+ } = this.state;
+
+ if (type === 21) {
+ return this.parseBindingRestProperty(prop);
+ } else if (type === 134) {
+ this.expectPlugin("destructuringPrivate", startLoc);
+ this.classScope.usePrivateName(this.state.value, startLoc);
+ prop.key = this.parsePrivateName();
+ } else {
+ this.parsePropertyName(prop);
+ }
+
+ prop.method = false;
+ this.parseObjPropValue(prop, startPos, startLoc, false, false, true, false);
+ return prop;
+ }
+
+ 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) {
+ var _startLoc, _startPos, _left;
+
+ startLoc = (_startLoc = startLoc) != null ? _startLoc : this.state.startLoc;
+ startPos = (_startPos = startPos) != null ? _startPos : this.state.start;
+ left = (_left = left) != null ? _left : this.parseBindingAtom();
+ if (!this.eat(29)) return left;
+ const node = this.startNodeAt(startPos, startLoc);
+ node.left = left;
+ node.right = this.parseMaybeAssignAllowIn();
+ return this.finishNode(node, "AssignmentPattern");
+ }
+
+ checkLVal(expr, contextDescription, bindingType = BIND_NONE, checkClashes, disallowLetBinding, strictModeChanged = false) {
+ switch (expr.type) {
+ case "Identifier":
+ {
+ const {
+ name
+ } = expr;
+
+ if (this.state.strict && (strictModeChanged ? isStrictBindReservedWord(name, this.inModule) : isStrictBindOnlyReservedWord(name))) {
+ this.raise(bindingType === BIND_NONE ? ErrorMessages.StrictEvalArguments : ErrorMessages.StrictEvalArgumentsBinding, {
+ node: expr
+ }, name);
+ }
+
+ if (checkClashes) {
+ if (checkClashes.has(name)) {
+ this.raise(ErrorMessages.ParamDupe, {
+ node: expr
+ });
+ } else {
+ checkClashes.add(name);
+ }
+ }
+
+ if (disallowLetBinding && name === "let") {
+ this.raise(ErrorMessages.LetInLexicalBinding, {
+ node: expr
+ });
+ }
+
+ if (!(bindingType & BIND_NONE)) {
+ this.scope.declareName(name, bindingType, expr.loc.start);
+ }
+
+ break;
+ }
+
+ case "MemberExpression":
+ if (bindingType !== BIND_NONE) {
+ this.raise(ErrorMessages.InvalidPropertyBindingPattern, {
+ node: expr
+ });
+ }
+
+ break;
+
+ case "ObjectPattern":
+ for (let prop of expr.properties) {
+ if (this.isObjectProperty(prop)) prop = prop.value;else if (this.isObjectMethod(prop)) continue;
+ this.checkLVal(prop, "object destructuring pattern", bindingType, checkClashes, disallowLetBinding);
+ }
+
+ break;
+
+ case "ArrayPattern":
+ for (const elem of expr.elements) {
+ if (elem) {
+ this.checkLVal(elem, "array destructuring pattern", bindingType, checkClashes, disallowLetBinding);
+ }
+ }
+
+ break;
+
+ case "AssignmentPattern":
+ this.checkLVal(expr.left, "assignment pattern", bindingType, checkClashes);
+ break;
+
+ case "RestElement":
+ this.checkLVal(expr.argument, "rest element", bindingType, checkClashes);
+ break;
+
+ case "ParenthesizedExpression":
+ this.checkLVal(expr.expression, "parenthesized expression", bindingType, checkClashes);
+ break;
+
+ default:
+ {
+ this.raise(bindingType === BIND_NONE ? ErrorMessages.InvalidLhs : ErrorMessages.InvalidLhsBinding, {
+ node: expr
+ }, contextDescription);
+ }
+ }
+ }
+
+ checkToRestConversion(node) {
+ if (node.argument.type !== "Identifier" && node.argument.type !== "MemberExpression") {
+ this.raise(ErrorMessages.InvalidRestAssignmentPattern, {
+ node: node.argument
+ });
+ }
+ }
+
+ checkCommaAfterRest(close) {
+ if (!this.match(12)) {
+ return false;
+ }
+
+ this.raise(this.lookaheadCharCode() === close ? ErrorMessages.RestTrailingComma : ErrorMessages.ElementAfterRest, {
+ at: this.state.startLoc
+ });
+ return true;
+ }
+
+}
+
+const invalidHackPipeBodies = new Map([["ArrowFunctionExpression", "arrow function"], ["AssignmentExpression", "assignment"], ["ConditionalExpression", "conditional"], ["YieldExpression", "yield"]]);
+class ExpressionParser extends LValParser {
+ checkProto(prop, isRecord, protoRef, refExpressionErrors) {
+ if (prop.type === "SpreadElement" || this.isObjectMethod(prop) || prop.computed || prop.shorthand) {
+ return;
+ }
+
+ const key = prop.key;
+ const name = key.type === "Identifier" ? key.name : key.value;
+
+ if (name === "__proto__") {
+ if (isRecord) {
+ this.raise(ErrorMessages.RecordNoProto, {
+ node: key
+ });
+ return;
+ }
+
+ if (protoRef.used) {
+ if (refExpressionErrors) {
+ if (refExpressionErrors.doubleProtoLoc === null) {
+ refExpressionErrors.doubleProtoLoc = key.loc.start;
+ }
+ } else {
+ this.raise(ErrorMessages.DuplicateProto, {
+ node: key
+ });
+ }
+ }
+
+ protoRef.used = true;
+ }
+ }
+
+ shouldExitDescending(expr, potentialArrowAt) {
+ return expr.type === "ArrowFunctionExpression" && expr.start === potentialArrowAt;
+ }
+
+ getExpression() {
+ this.enterInitialScopes();
+ this.nextToken();
+ const expr = this.parseExpression();
+
+ if (!this.match(135)) {
+ this.unexpected();
+ }
+
+ this.finalizeRemainingComments();
+ expr.comments = this.state.comments;
+ expr.errors = this.state.errors;
+
+ if (this.options.tokens) {
+ expr.tokens = this.tokens;
+ }
+
+ return expr;
+ }
+
+ parseExpression(disallowIn, refExpressionErrors) {
+ if (disallowIn) {
+ return this.disallowInAnd(() => this.parseExpressionBase(refExpressionErrors));
+ }
+
+ return this.allowInAnd(() => this.parseExpressionBase(refExpressionErrors));
+ }
+
+ parseExpressionBase(refExpressionErrors) {
+ const startPos = this.state.start;
+ const startLoc = this.state.startLoc;
+ const expr = this.parseMaybeAssign(refExpressionErrors);
+
+ if (this.match(12)) {
+ const node = this.startNodeAt(startPos, startLoc);
+ node.expressions = [expr];
+
+ while (this.eat(12)) {
+ node.expressions.push(this.parseMaybeAssign(refExpressionErrors));
+ }
+
+ this.toReferencedList(node.expressions);
+ return this.finishNode(node, "SequenceExpression");
+ }
+
+ return expr;
+ }
+
+ parseMaybeAssignDisallowIn(refExpressionErrors, afterLeftParse) {
+ return this.disallowInAnd(() => this.parseMaybeAssign(refExpressionErrors, afterLeftParse));
+ }
+
+ parseMaybeAssignAllowIn(refExpressionErrors, afterLeftParse) {
+ return this.allowInAnd(() => this.parseMaybeAssign(refExpressionErrors, afterLeftParse));
+ }
+
+ setOptionalParametersError(refExpressionErrors, resultError) {
+ var _resultError$loc;
+
+ refExpressionErrors.optionalParametersLoc = (_resultError$loc = resultError == null ? void 0 : resultError.loc) != null ? _resultError$loc : this.state.startLoc;
+ }
+
+ parseMaybeAssign(refExpressionErrors, afterLeftParse) {
+ const startPos = this.state.start;
+ const startLoc = this.state.startLoc;
+
+ if (this.isContextual(105)) {
+ if (this.prodParam.hasYield) {
+ let left = this.parseYield();
+
+ if (afterLeftParse) {
+ left = afterLeftParse.call(this, left, startPos, startLoc);
+ }
+
+ return left;
+ }
+ }
+
+ let ownExpressionErrors;
+
+ if (refExpressionErrors) {
+ ownExpressionErrors = false;
+ } else {
+ refExpressionErrors = new ExpressionErrors();
+ ownExpressionErrors = true;
+ }
+
+ const {
+ type
+ } = this.state;
+
+ if (type === 10 || tokenIsIdentifier(type)) {
+ this.state.potentialArrowAt = this.state.start;
+ }
+
+ let left = this.parseMaybeConditional(refExpressionErrors);
+
+ if (afterLeftParse) {
+ left = afterLeftParse.call(this, left, startPos, startLoc);
+ }
+
+ if (tokenIsAssignment(this.state.type)) {
+ const node = this.startNodeAt(startPos, startLoc);
+ const operator = this.state.value;
+ node.operator = operator;
+
+ if (this.match(29)) {
+ node.left = this.toAssignable(left, true);
+
+ if (refExpressionErrors.doubleProtoLoc != null && refExpressionErrors.doubleProtoLoc.index >= startPos) {
+ refExpressionErrors.doubleProtoLoc = null;
+ }
+
+ if (refExpressionErrors.shorthandAssignLoc != null && refExpressionErrors.shorthandAssignLoc.index >= startPos) {
+ refExpressionErrors.shorthandAssignLoc = null;
+ }
+
+ if (refExpressionErrors.privateKeyLoc != null && refExpressionErrors.privateKeyLoc.index >= startPos) {
+ this.checkDestructuringPrivate(refExpressionErrors);
+ refExpressionErrors.privateKeyLoc = null;
+ }
+ } else {
+ node.left = left;
+ }
+
+ this.checkLVal(left, "assignment expression");
+ this.next();
+ node.right = this.parseMaybeAssign();
+ return this.finishNode(node, "AssignmentExpression");
+ } else if (ownExpressionErrors) {
+ this.checkExpressionErrors(refExpressionErrors, true);
+ }
+
+ return left;
+ }
+
+ parseMaybeConditional(refExpressionErrors) {
+ const startPos = this.state.start;
+ const startLoc = this.state.startLoc;
+ const potentialArrowAt = this.state.potentialArrowAt;
+ const expr = this.parseExprOps(refExpressionErrors);
+
+ if (this.shouldExitDescending(expr, potentialArrowAt)) {
+ return expr;
+ }
+
+ return this.parseConditional(expr, startPos, startLoc, refExpressionErrors);
+ }
+
+ parseConditional(expr, startPos, startLoc, refExpressionErrors) {
+ if (this.eat(17)) {
+ const node = this.startNodeAt(startPos, startLoc);
+ node.test = expr;
+ node.consequent = this.parseMaybeAssignAllowIn();
+ this.expect(14);
+ node.alternate = this.parseMaybeAssign();
+ return this.finishNode(node, "ConditionalExpression");
+ }
+
+ return expr;
+ }
+
+ parseMaybeUnaryOrPrivate(refExpressionErrors) {
+ return this.match(134) ? this.parsePrivateName() : this.parseMaybeUnary(refExpressionErrors);
+ }
+
+ parseExprOps(refExpressionErrors) {
+ const startPos = this.state.start;
+ const startLoc = this.state.startLoc;
+ const potentialArrowAt = this.state.potentialArrowAt;
+ const expr = this.parseMaybeUnaryOrPrivate(refExpressionErrors);
+
+ if (this.shouldExitDescending(expr, potentialArrowAt)) {
+ return expr;
+ }
+
+ return this.parseExprOp(expr, startPos, startLoc, -1);
+ }
+
+ parseExprOp(left, leftStartPos, leftStartLoc, minPrec) {
+ if (this.isPrivateName(left)) {
+ const value = this.getPrivateNameSV(left);
+
+ if (minPrec >= tokenOperatorPrecedence(58) || !this.prodParam.hasIn || !this.match(58)) {
+ this.raise(ErrorMessages.PrivateInExpectedIn, {
+ node: left
+ }, value);
+ }
+
+ this.classScope.usePrivateName(value, left.loc.start);
+ }
+
+ const op = this.state.type;
+
+ if (tokenIsOperator(op) && (this.prodParam.hasIn || !this.match(58))) {
+ let prec = tokenOperatorPrecedence(op);
+
+ if (prec > minPrec) {
+ if (op === 39) {
+ this.expectPlugin("pipelineOperator");
+
+ if (this.state.inFSharpPipelineDirectBody) {
+ return left;
+ }
+
+ this.checkPipelineAtInfixOperator(left, leftStartLoc);
+ }
+
+ const node = this.startNodeAt(leftStartPos, leftStartLoc);
+ node.left = left;
+ node.operator = this.state.value;
+ const logical = op === 41 || op === 42;
+ const coalesce = op === 40;
+
+ if (coalesce) {
+ prec = tokenOperatorPrecedence(42);
+ }
+
+ this.next();
+
+ if (op === 39 && this.hasPlugin(["pipelineOperator", {
+ proposal: "minimal"
+ }])) {
+ if (this.state.type === 96 && this.prodParam.hasAwait) {
+ throw this.raise(ErrorMessages.UnexpectedAwaitAfterPipelineBody, {
+ at: this.state.startLoc
+ });
+ }
+ }
+
+ node.right = this.parseExprOpRightExpr(op, prec);
+ this.finishNode(node, logical || coalesce ? "LogicalExpression" : "BinaryExpression");
+ const nextOp = this.state.type;
+
+ if (coalesce && (nextOp === 41 || nextOp === 42) || logical && nextOp === 40) {
+ throw this.raise(ErrorMessages.MixingCoalesceWithLogical, {
+ at: this.state.startLoc
+ });
+ }
+
+ return this.parseExprOp(node, leftStartPos, leftStartLoc, minPrec);
+ }
+ }
+
+ return left;
+ }
+
+ parseExprOpRightExpr(op, prec) {
+ const startPos = this.state.start;
+ const startLoc = this.state.startLoc;
+
+ switch (op) {
+ case 39:
+ switch (this.getPluginOption("pipelineOperator", "proposal")) {
+ case "hack":
+ return this.withTopicBindingContext(() => {
+ return this.parseHackPipeBody();
+ });
+
+ case "smart":
+ return this.withTopicBindingContext(() => {
+ if (this.prodParam.hasYield && this.isContextual(105)) {
+ throw this.raise(ErrorMessages.PipeBodyIsTighter, {
+ at: this.state.startLoc
+ }, this.state.value);
+ }
+
+ return this.parseSmartPipelineBodyInStyle(this.parseExprOpBaseRightExpr(op, prec), startPos, startLoc);
+ });
+
+ case "fsharp":
+ return this.withSoloAwaitPermittingContext(() => {
+ return this.parseFSharpPipelineBody(prec);
+ });
+ }
+
+ default:
+ return this.parseExprOpBaseRightExpr(op, prec);
+ }
+ }
+
+ parseExprOpBaseRightExpr(op, prec) {
+ const startPos = this.state.start;
+ const startLoc = this.state.startLoc;
+ return this.parseExprOp(this.parseMaybeUnaryOrPrivate(), startPos, startLoc, tokenIsRightAssociative(op) ? prec - 1 : prec);
+ }
+
+ parseHackPipeBody() {
+ var _body$extra;
+
+ const {
+ startLoc
+ } = this.state;
+ const body = this.parseMaybeAssign();
+
+ if (invalidHackPipeBodies.has(body.type) && !((_body$extra = body.extra) != null && _body$extra.parenthesized)) {
+ this.raise(ErrorMessages.PipeUnparenthesizedBody, {
+ at: startLoc
+ }, invalidHackPipeBodies.get(body.type));
+ }
+
+ if (!this.topicReferenceWasUsedInCurrentContext()) {
+ this.raise(ErrorMessages.PipeTopicUnused, {
+ at: startLoc
+ });
+ }
+
+ return body;
+ }
+
+ checkExponentialAfterUnary(node) {
+ if (this.match(57)) {
+ this.raise(ErrorMessages.UnexpectedTokenUnaryExponentiation, {
+ node: node.argument
+ });
+ }
+ }
+
+ parseMaybeUnary(refExpressionErrors, sawUnary) {
+ const startPos = this.state.start;
+ const startLoc = this.state.startLoc;
+ const isAwait = this.isContextual(96);
+
+ if (isAwait && this.isAwaitAllowed()) {
+ this.next();
+ const expr = this.parseAwait(startPos, startLoc);
+ if (!sawUnary) this.checkExponentialAfterUnary(expr);
+ return expr;
+ }
+
+ const update = this.match(34);
+ const node = this.startNode();
+
+ if (tokenIsPrefix(this.state.type)) {
+ node.operator = this.state.value;
+ node.prefix = true;
+
+ if (this.match(72)) {
+ this.expectPlugin("throwExpressions");
+ }
+
+ const isDelete = this.match(89);
+ this.next();
+ node.argument = this.parseMaybeUnary(null, true);
+ this.checkExpressionErrors(refExpressionErrors, true);
+
+ if (this.state.strict && isDelete) {
+ const arg = node.argument;
+
+ if (arg.type === "Identifier") {
+ this.raise(ErrorMessages.StrictDelete, {
+ node
+ });
+ } else if (this.hasPropertyAsPrivateName(arg)) {
+ this.raise(ErrorMessages.DeletePrivateField, {
+ node
+ });
+ }
+ }
+
+ if (!update) {
+ if (!sawUnary) this.checkExponentialAfterUnary(node);
+ return this.finishNode(node, "UnaryExpression");
+ }
+ }
+
+ const expr = this.parseUpdate(node, update, refExpressionErrors);
+
+ if (isAwait) {
+ const {
+ type
+ } = this.state;
+ const startsExpr = this.hasPlugin("v8intrinsic") ? tokenCanStartExpression(type) : tokenCanStartExpression(type) && !this.match(54);
+
+ if (startsExpr && !this.isAmbiguousAwait()) {
+ this.raiseOverwrite(startLoc, ErrorMessages.AwaitNotInAsyncContext);
+ return this.parseAwait(startPos, startLoc);
+ }
+ }
+
+ return expr;
+ }
+
+ parseUpdate(node, update, refExpressionErrors) {
+ if (update) {
+ this.checkLVal(node.argument, "prefix operation");
+ return this.finishNode(node, "UpdateExpression");
+ }
+
+ const startPos = this.state.start;
+ const startLoc = this.state.startLoc;
+ let expr = this.parseExprSubscripts(refExpressionErrors);
+ if (this.checkExpressionErrors(refExpressionErrors, false)) return expr;
+
+ while (tokenIsPostfix(this.state.type) && !this.canInsertSemicolon()) {
+ const node = this.startNodeAt(startPos, startLoc);
+ node.operator = this.state.value;
+ node.prefix = false;
+ node.argument = expr;
+ this.checkLVal(expr, "postfix operation");
+ this.next();
+ expr = this.finishNode(node, "UpdateExpression");
+ }
+
+ return expr;
+ }
+
+ parseExprSubscripts(refExpressionErrors) {
+ const startPos = this.state.start;
+ const startLoc = this.state.startLoc;
+ const potentialArrowAt = this.state.potentialArrowAt;
+ const expr = this.parseExprAtom(refExpressionErrors);
+
+ if (this.shouldExitDescending(expr, potentialArrowAt)) {
+ return expr;
+ }
+
+ return this.parseSubscripts(expr, startPos, startLoc);
+ }
+
+ parseSubscripts(base, startPos, startLoc, noCalls) {
+ const state = {
+ optionalChainMember: false,
+ maybeAsyncArrow: this.atPossibleAsyncArrow(base),
+ stop: false
+ };
+
+ do {
+ base = this.parseSubscript(base, startPos, startLoc, noCalls, state);
+ state.maybeAsyncArrow = false;
+ } while (!state.stop);
+
+ return base;
+ }
+
+ parseSubscript(base, startPos, startLoc, noCalls, state) {
+ const {
+ type
+ } = this.state;
+
+ if (!noCalls && type === 15) {
+ return this.parseBind(base, startPos, startLoc, noCalls, state);
+ } else if (tokenIsTemplate(type)) {
+ return this.parseTaggedTemplateExpression(base, startPos, startLoc, state);
+ }
+
+ let optional = false;
+
+ if (type === 18) {
+ if (noCalls && this.lookaheadCharCode() === 40) {
+ state.stop = true;
+ return base;
+ }
+
+ state.optionalChainMember = optional = true;
+ this.next();
+ }
+
+ if (!noCalls && this.match(10)) {
+ return this.parseCoverCallAndAsyncArrowHead(base, startPos, startLoc, state, optional);
+ } else {
+ const computed = this.eat(0);
+
+ if (computed || optional || this.eat(16)) {
+ return this.parseMember(base, startPos, startLoc, state, computed, optional);
+ } else {
+ state.stop = true;
+ return base;
+ }
+ }
+ }
+
+ parseMember(base, startPos, startLoc, state, computed, optional) {
+ const node = this.startNodeAt(startPos, startLoc);
+ node.object = base;
+ node.computed = computed;
+
+ if (computed) {
+ node.property = this.parseExpression();
+ this.expect(3);
+ } else if (this.match(134)) {
+ if (base.type === "Super") {
+ this.raise(ErrorMessages.SuperPrivateField, {
+ at: startLoc
+ });
+ }
+
+ this.classScope.usePrivateName(this.state.value, this.state.startLoc);
+ node.property = this.parsePrivateName();
+ } else {
+ node.property = this.parseIdentifier(true);
+ }
+
+ if (state.optionalChainMember) {
+ node.optional = optional;
+ return this.finishNode(node, "OptionalMemberExpression");
+ } else {
+ return this.finishNode(node, "MemberExpression");
+ }
+ }
+
+ parseBind(base, startPos, startLoc, noCalls, state) {
+ const node = this.startNodeAt(startPos, startLoc);
+ node.object = base;
+ this.next();
+ node.callee = this.parseNoCallExpr();
+ state.stop = true;
+ return this.parseSubscripts(this.finishNode(node, "BindExpression"), startPos, startLoc, noCalls);
+ }
+
+ parseCoverCallAndAsyncArrowHead(base, startPos, startLoc, state, optional) {
+ const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;
+ let refExpressionErrors = null;
+ this.state.maybeInArrowParameters = true;
+ this.next();
+ let node = this.startNodeAt(startPos, startLoc);
+ node.callee = base;
+ const {
+ maybeAsyncArrow,
+ optionalChainMember
+ } = state;
+
+ if (maybeAsyncArrow) {
+ this.expressionScope.enter(newAsyncArrowScope());
+ refExpressionErrors = new ExpressionErrors();
+ }
+
+ if (optionalChainMember) {
+ node.optional = optional;
+ }
+
+ if (optional) {
+ node.arguments = this.parseCallExpressionArguments(11);
+ } else {
+ node.arguments = this.parseCallExpressionArguments(11, base.type === "Import", base.type !== "Super", node, refExpressionErrors);
+ }
+
+ this.finishCallExpression(node, optionalChainMember);
+
+ if (maybeAsyncArrow && this.shouldParseAsyncArrow() && !optional) {
+ state.stop = true;
+ this.checkDestructuringPrivate(refExpressionErrors);
+ this.expressionScope.validateAsPattern();
+ this.expressionScope.exit();
+ node = this.parseAsyncArrowFromCallExpression(this.startNodeAt(startPos, startLoc), node);
+ } else {
+ if (maybeAsyncArrow) {
+ this.checkExpressionErrors(refExpressionErrors, true);
+ this.expressionScope.exit();
+ }
+
+ this.toReferencedArguments(node);
+ }
+
+ this.state.maybeInArrowParameters = oldMaybeInArrowParameters;
+ return node;
+ }
+
+ toReferencedArguments(node, isParenthesizedExpr) {
+ this.toReferencedListDeep(node.arguments, isParenthesizedExpr);
+ }
+
+ parseTaggedTemplateExpression(base, startPos, startLoc, state) {
+ const node = this.startNodeAt(startPos, startLoc);
+ node.tag = base;
+ node.quasi = this.parseTemplate(true);
+
+ if (state.optionalChainMember) {
+ this.raise(ErrorMessages.OptionalChainingNoTemplate, {
+ at: startLoc
+ });
+ }
+
+ return this.finishNode(node, "TaggedTemplateExpression");
+ }
+
+ atPossibleAsyncArrow(base) {
+ return base.type === "Identifier" && base.name === "async" && this.state.lastTokEndLoc.index === base.end && !this.canInsertSemicolon() && base.end - base.start === 5 && base.start === this.state.potentialArrowAt;
+ }
+
+ finishCallExpression(node, optional) {
+ if (node.callee.type === "Import") {
+ if (node.arguments.length === 2) {
+ {
+ if (!this.hasPlugin("moduleAttributes")) {
+ this.expectPlugin("importAssertions");
+ }
+ }
+ }
+
+ if (node.arguments.length === 0 || node.arguments.length > 2) {
+ this.raise(ErrorMessages.ImportCallArity, {
+ node
+ }, this.hasPlugin("importAssertions") || this.hasPlugin("moduleAttributes") ? "one or two arguments" : "one argument");
+ } else {
+ for (const arg of node.arguments) {
+ if (arg.type === "SpreadElement") {
+ this.raise(ErrorMessages.ImportCallSpreadArgument, {
+ node: arg
+ });
+ }
+ }
+ }
+ }
+
+ return this.finishNode(node, optional ? "OptionalCallExpression" : "CallExpression");
+ }
+
+ parseCallExpressionArguments(close, dynamicImport, allowPlaceholder, nodeForExtra, refExpressionErrors) {
+ const elts = [];
+ let first = true;
+ const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;
+ this.state.inFSharpPipelineDirectBody = false;
+
+ while (!this.eat(close)) {
+ if (first) {
+ first = false;
+ } else {
+ this.expect(12);
+
+ if (this.match(close)) {
+ if (dynamicImport && !this.hasPlugin("importAssertions") && !this.hasPlugin("moduleAttributes")) {
+ this.raise(ErrorMessages.ImportCallArgumentTrailingComma, {
+ at: this.state.lastTokStartLoc
+ });
+ }
+
+ if (nodeForExtra) {
+ this.addTrailingCommaExtraToNode(nodeForExtra);
+ }
+
+ this.next();
+ break;
+ }
+ }
+
+ elts.push(this.parseExprListItem(false, refExpressionErrors, allowPlaceholder));
+ }
+
+ this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;
+ return elts;
+ }
+
+ shouldParseAsyncArrow() {
+ return this.match(19) && !this.canInsertSemicolon();
+ }
+
+ parseAsyncArrowFromCallExpression(node, call) {
+ var _call$extra;
+
+ this.resetPreviousNodeTrailingComments(call);
+ this.expect(19);
+ this.parseArrowExpression(node, call.arguments, true, (_call$extra = call.extra) == null ? void 0 : _call$extra.trailingCommaLoc);
+
+ if (call.innerComments) {
+ setInnerComments(node, call.innerComments);
+ }
+
+ if (call.callee.trailingComments) {
+ setInnerComments(node, call.callee.trailingComments);
+ }
+
+ return node;
+ }
+
+ parseNoCallExpr() {
+ const startPos = this.state.start;
+ const startLoc = this.state.startLoc;
+ return this.parseSubscripts(this.parseExprAtom(), startPos, startLoc, true);
+ }
+
+ parseExprAtom(refExpressionErrors) {
+ let node;
+ const {
+ type
+ } = this.state;
+
+ switch (type) {
+ case 79:
+ return this.parseSuper();
+
+ case 83:
+ node = this.startNode();
+ this.next();
+
+ if (this.match(16)) {
+ return this.parseImportMetaProperty(node);
+ }
+
+ if (!this.match(10)) {
+ this.raise(ErrorMessages.UnsupportedImport, {
+ at: this.state.lastTokStartLoc
+ });
+ }
+
+ return this.finishNode(node, "Import");
+
+ case 78:
+ node = this.startNode();
+ this.next();
+ return this.finishNode(node, "ThisExpression");
+
+ case 90:
+ {
+ return this.parseDo(this.startNode(), false);
+ }
+
+ case 56:
+ case 31:
+ {
+ this.readRegexp();
+ return this.parseRegExpLiteral(this.state.value);
+ }
+
+ case 130:
+ return this.parseNumericLiteral(this.state.value);
+
+ case 131:
+ return this.parseBigIntLiteral(this.state.value);
+
+ case 132:
+ return this.parseDecimalLiteral(this.state.value);
+
+ case 129:
+ return this.parseStringLiteral(this.state.value);
+
+ case 84:
+ return this.parseNullLiteral();
+
+ case 85:
+ return this.parseBooleanLiteral(true);
+
+ case 86:
+ return this.parseBooleanLiteral(false);
+
+ case 10:
+ {
+ const canBeArrow = this.state.potentialArrowAt === this.state.start;
+ return this.parseParenAndDistinguishExpression(canBeArrow);
+ }
+
+ case 2:
+ case 1:
+ {
+ return this.parseArrayLike(this.state.type === 2 ? 4 : 3, false, true);
+ }
+
+ case 0:
+ {
+ return this.parseArrayLike(3, true, false, refExpressionErrors);
+ }
+
+ case 6:
+ case 7:
+ {
+ return this.parseObjectLike(this.state.type === 6 ? 9 : 8, false, true);
+ }
+
+ case 5:
+ {
+ return this.parseObjectLike(8, false, false, refExpressionErrors);
+ }
+
+ case 68:
+ return this.parseFunctionOrFunctionSent();
+
+ case 26:
+ this.parseDecorators();
+
+ case 80:
+ node = this.startNode();
+ this.takeDecorators(node);
+ return this.parseClass(node, false);
+
+ case 77:
+ return this.parseNewOrNewTarget();
+
+ case 25:
+ case 24:
+ return this.parseTemplate(false);
+
+ case 15:
+ {
+ node = this.startNode();
+ this.next();
+ node.object = null;
+ const callee = node.callee = this.parseNoCallExpr();
+
+ if (callee.type === "MemberExpression") {
+ return this.finishNode(node, "BindExpression");
+ } else {
+ throw this.raise(ErrorMessages.UnsupportedBind, {
+ node: callee
+ });
+ }
+ }
+
+ case 134:
+ {
+ this.raise(ErrorMessages.PrivateInExpectedIn, {
+ at: this.state.startLoc
+ }, this.state.value);
+ return this.parsePrivateName();
+ }
+
+ case 33:
+ {
+ return this.parseTopicReferenceThenEqualsSign(54, "%");
+ }
+
+ case 32:
+ {
+ return this.parseTopicReferenceThenEqualsSign(44, "^");
+ }
+
+ case 37:
+ case 38:
+ {
+ return this.parseTopicReference("hack");
+ }
+
+ case 44:
+ case 54:
+ case 27:
+ {
+ const pipeProposal = this.getPluginOption("pipelineOperator", "proposal");
+
+ if (pipeProposal) {
+ return this.parseTopicReference(pipeProposal);
+ } else {
+ throw this.unexpected();
+ }
+ }
+
+ case 47:
+ {
+ const lookaheadCh = this.input.codePointAt(this.nextTokenStart());
+
+ if (isIdentifierStart(lookaheadCh) || lookaheadCh === 62) {
+ this.expectOnePlugin(["jsx", "flow", "typescript"]);
+ break;
+ } else {
+ throw this.unexpected();
+ }
+ }
+
+ default:
+ if (tokenIsIdentifier(type)) {
+ if (this.isContextual(123) && this.lookaheadCharCode() === 123 && !this.hasFollowingLineBreak()) {
+ return this.parseModuleExpression();
+ }
+
+ const canBeArrow = this.state.potentialArrowAt === this.state.start;
+ const containsEsc = this.state.containsEsc;
+ const id = this.parseIdentifier();
+
+ if (!containsEsc && id.name === "async" && !this.canInsertSemicolon()) {
+ const {
+ type
+ } = this.state;
+
+ if (type === 68) {
+ this.resetPreviousNodeTrailingComments(id);
+ this.next();
+ return this.parseFunction(this.startNodeAtNode(id), undefined, true);
+ } else if (tokenIsIdentifier(type)) {
+ if (this.lookaheadCharCode() === 61) {
+ return this.parseAsyncArrowUnaryFunction(this.startNodeAtNode(id));
+ } else {
+ return id;
+ }
+ } else if (type === 90) {
+ this.resetPreviousNodeTrailingComments(id);
+ return this.parseDo(this.startNodeAtNode(id), true);
+ }
+ }
+
+ if (canBeArrow && this.match(19) && !this.canInsertSemicolon()) {
+ this.next();
+ return this.parseArrowExpression(this.startNodeAtNode(id), [id], false);
+ }
+
+ return id;
+ } else {
+ throw this.unexpected();
+ }
+
+ }
+ }
+
+ parseTopicReferenceThenEqualsSign(topicTokenType, topicTokenValue) {
+ const pipeProposal = this.getPluginOption("pipelineOperator", "proposal");
+
+ if (pipeProposal) {
+ this.state.type = topicTokenType;
+ this.state.value = topicTokenValue;
+ this.state.pos--;
+ this.state.end--;
+ this.state.endLoc = createPositionWithColumnOffset(this.state.endLoc, -1);
+ return this.parseTopicReference(pipeProposal);
+ } else {
+ throw this.unexpected();
+ }
+ }
+
+ parseTopicReference(pipeProposal) {
+ const node = this.startNode();
+ const startLoc = this.state.startLoc;
+ const tokenType = this.state.type;
+ this.next();
+ return this.finishTopicReference(node, startLoc, pipeProposal, tokenType);
+ }
+
+ finishTopicReference(node, startLoc, pipeProposal, tokenType) {
+ if (this.testTopicReferenceConfiguration(pipeProposal, startLoc, tokenType)) {
+ const nodeType = pipeProposal === "smart" ? "PipelinePrimaryTopicReference" : "TopicReference";
+
+ if (!this.topicReferenceIsAllowedInCurrentContext()) {
+ this.raise(pipeProposal === "smart" ? ErrorMessages.PrimaryTopicNotAllowed : ErrorMessages.PipeTopicUnbound, {
+ at: startLoc
+ });
+ }
+
+ this.registerTopicReference();
+ return this.finishNode(node, nodeType);
+ } else {
+ throw this.raise(ErrorMessages.PipeTopicUnconfiguredToken, {
+ at: startLoc
+ }, tokenLabelName(tokenType));
+ }
+ }
+
+ testTopicReferenceConfiguration(pipeProposal, startLoc, tokenType) {
+ switch (pipeProposal) {
+ case "hack":
+ {
+ return this.hasPlugin(["pipelineOperator", {
+ topicToken: tokenLabelName(tokenType)
+ }]);
+ }
+
+ case "smart":
+ return tokenType === 27;
+
+ default:
+ throw this.raise(ErrorMessages.PipeTopicRequiresHackPipes, {
+ at: startLoc
+ });
+ }
+ }
+
+ parseAsyncArrowUnaryFunction(node) {
+ this.prodParam.enter(functionFlags(true, this.prodParam.hasYield));
+ const params = [this.parseIdentifier()];
+ this.prodParam.exit();
+
+ if (this.hasPrecedingLineBreak()) {
+ this.raise(ErrorMessages.LineTerminatorBeforeArrow, {
+ at: this.state.curPosition()
+ });
+ }
+
+ this.expect(19);
+ this.parseArrowExpression(node, params, true);
+ return node;
+ }
+
+ parseDo(node, isAsync) {
+ this.expectPlugin("doExpressions");
+
+ if (isAsync) {
+ this.expectPlugin("asyncDoExpressions");
+ }
+
+ node.async = isAsync;
+ this.next();
+ const oldLabels = this.state.labels;
+ this.state.labels = [];
+
+ if (isAsync) {
+ this.prodParam.enter(PARAM_AWAIT);
+ node.body = this.parseBlock();
+ this.prodParam.exit();
+ } else {
+ node.body = this.parseBlock();
+ }
+
+ this.state.labels = oldLabels;
+ return this.finishNode(node, "DoExpression");
+ }
+
+ parseSuper() {
+ const node = this.startNode();
+ this.next();
+
+ if (this.match(10) && !this.scope.allowDirectSuper && !this.options.allowSuperOutsideMethod) {
+ this.raise(ErrorMessages.SuperNotAllowed, {
+ node
+ });
+ } else if (!this.scope.allowSuper && !this.options.allowSuperOutsideMethod) {
+ this.raise(ErrorMessages.UnexpectedSuper, {
+ node
+ });
+ }
+
+ if (!this.match(10) && !this.match(0) && !this.match(16)) {
+ this.raise(ErrorMessages.UnsupportedSuper, {
+ node
+ });
+ }
+
+ return this.finishNode(node, "Super");
+ }
+
+ parsePrivateName() {
+ const node = this.startNode();
+ const id = this.startNodeAt(this.state.start + 1, new Position(this.state.curLine, this.state.start + 1 - this.state.lineStart, this.state.start + 1));
+ const name = this.state.value;
+ this.next();
+ node.id = this.createIdentifier(id, name);
+ return this.finishNode(node, "PrivateName");
+ }
+
+ parseFunctionOrFunctionSent() {
+ const node = this.startNode();
+ this.next();
+
+ if (this.prodParam.hasYield && this.match(16)) {
+ const meta = this.createIdentifier(this.startNodeAtNode(node), "function");
+ this.next();
+
+ if (this.match(102)) {
+ this.expectPlugin("functionSent");
+ } else if (!this.hasPlugin("functionSent")) {
+ this.unexpected();
+ }
+
+ return this.parseMetaProperty(node, meta, "sent");
+ }
+
+ return this.parseFunction(node);
+ }
+
+ parseMetaProperty(node, meta, propertyName) {
+ node.meta = meta;
+ const containsEsc = this.state.containsEsc;
+ node.property = this.parseIdentifier(true);
+
+ if (node.property.name !== propertyName || containsEsc) {
+ this.raise(ErrorMessages.UnsupportedMetaProperty, {
+ node: node.property
+ }, meta.name, propertyName);
+ }
+
+ return this.finishNode(node, "MetaProperty");
+ }
+
+ parseImportMetaProperty(node) {
+ const id = this.createIdentifier(this.startNodeAtNode(node), "import");
+ this.next();
+
+ if (this.isContextual(100)) {
+ if (!this.inModule) {
+ this.raise(SourceTypeModuleErrorMessages.ImportMetaOutsideModule, {
+ node: id
+ });
+ }
+
+ this.sawUnambiguousESM = true;
+ }
+
+ return this.parseMetaProperty(node, id, "meta");
+ }
+
+ parseLiteralAtNode(value, type, node) {
+ this.addExtra(node, "rawValue", value);
+ this.addExtra(node, "raw", this.input.slice(node.start, this.state.end));
+ node.value = value;
+ this.next();
+ return this.finishNode(node, type);
+ }
+
+ parseLiteral(value, type) {
+ const node = this.startNode();
+ return this.parseLiteralAtNode(value, type, node);
+ }
+
+ parseStringLiteral(value) {
+ return this.parseLiteral(value, "StringLiteral");
+ }
+
+ parseNumericLiteral(value) {
+ return this.parseLiteral(value, "NumericLiteral");
+ }
+
+ parseBigIntLiteral(value) {
+ return this.parseLiteral(value, "BigIntLiteral");
+ }
+
+ parseDecimalLiteral(value) {
+ return this.parseLiteral(value, "DecimalLiteral");
+ }
+
+ parseRegExpLiteral(value) {
+ const node = this.parseLiteral(value.value, "RegExpLiteral");
+ node.pattern = value.pattern;
+ node.flags = value.flags;
+ return node;
+ }
+
+ parseBooleanLiteral(value) {
+ const node = this.startNode();
+ node.value = value;
+ this.next();
+ return this.finishNode(node, "BooleanLiteral");
+ }
+
+ parseNullLiteral() {
+ const node = this.startNode();
+ this.next();
+ return this.finishNode(node, "NullLiteral");
+ }
+
+ parseParenAndDistinguishExpression(canBeArrow) {
+ const startPos = this.state.start;
+ const startLoc = this.state.startLoc;
+ let val;
+ this.next();
+ this.expressionScope.enter(newArrowHeadScope());
+ const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;
+ const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;
+ this.state.maybeInArrowParameters = true;
+ this.state.inFSharpPipelineDirectBody = false;
+ const innerStartPos = this.state.start;
+ const innerStartLoc = this.state.startLoc;
+ const exprList = [];
+ const refExpressionErrors = new ExpressionErrors();
+ let first = true;
+ let spreadStartLoc;
+ let optionalCommaStartLoc;
+
+ while (!this.match(11)) {
+ if (first) {
+ first = false;
+ } else {
+ this.expect(12, refExpressionErrors.optionalParametersLoc === null ? null : refExpressionErrors.optionalParametersLoc);
+
+ if (this.match(11)) {
+ optionalCommaStartLoc = this.state.startLoc;
+ break;
+ }
+ }
+
+ if (this.match(21)) {
+ const spreadNodeStartPos = this.state.start;
+ const spreadNodeStartLoc = this.state.startLoc;
+ spreadStartLoc = this.state.startLoc;
+ exprList.push(this.parseParenItem(this.parseRestBinding(), spreadNodeStartPos, spreadNodeStartLoc));
+
+ if (!this.checkCommaAfterRest(41)) {
+ break;
+ }
+ } else {
+ exprList.push(this.parseMaybeAssignAllowIn(refExpressionErrors, this.parseParenItem));
+ }
+ }
+
+ const innerEndLoc = this.state.lastTokEndLoc;
+ this.expect(11);
+ this.state.maybeInArrowParameters = oldMaybeInArrowParameters;
+ this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;
+ let arrowNode = this.startNodeAt(startPos, startLoc);
+
+ if (canBeArrow && this.shouldParseArrow(exprList) && (arrowNode = this.parseArrow(arrowNode))) {
+ this.checkDestructuringPrivate(refExpressionErrors);
+ this.expressionScope.validateAsPattern();
+ this.expressionScope.exit();
+ this.parseArrowExpression(arrowNode, exprList, false);
+ return arrowNode;
+ }
+
+ this.expressionScope.exit();
+
+ if (!exprList.length) {
+ this.unexpected(this.state.lastTokStartLoc);
+ }
+
+ if (optionalCommaStartLoc) this.unexpected(optionalCommaStartLoc);
+ if (spreadStartLoc) this.unexpected(spreadStartLoc);
+ this.checkExpressionErrors(refExpressionErrors, true);
+ this.toReferencedListDeep(exprList, true);
+
+ if (exprList.length > 1) {
+ val = this.startNodeAt(innerStartPos, innerStartLoc);
+ val.expressions = exprList;
+ this.finishNode(val, "SequenceExpression");
+ this.resetEndLocation(val, innerEndLoc);
+ } else {
+ val = exprList[0];
+ }
+
+ if (!this.options.createParenthesizedExpressions) {
+ this.addExtra(val, "parenthesized", true);
+ this.addExtra(val, "parenStart", startPos);
+ this.takeSurroundingComments(val, startPos, this.state.lastTokEndLoc.index);
+ return val;
+ }
+
+ const parenExpression = this.startNodeAt(startPos, startLoc);
+ parenExpression.expression = val;
+ this.finishNode(parenExpression, "ParenthesizedExpression");
+ return parenExpression;
+ }
+
+ shouldParseArrow(params) {
+ return !this.canInsertSemicolon();
+ }
+
+ parseArrow(node) {
+ if (this.eat(19)) {
+ return node;
+ }
+ }
+
+ parseParenItem(node, startPos, startLoc) {
+ return node;
+ }
+
+ parseNewOrNewTarget() {
+ const node = this.startNode();
+ this.next();
+
+ if (this.match(16)) {
+ const meta = this.createIdentifier(this.startNodeAtNode(node), "new");
+ this.next();
+ const metaProp = this.parseMetaProperty(node, meta, "target");
+
+ if (!this.scope.inNonArrowFunction && !this.scope.inClass) {
+ this.raise(ErrorMessages.UnexpectedNewTarget, {
+ node: metaProp
+ });
+ }
+
+ return metaProp;
+ }
+
+ return this.parseNew(node);
+ }
+
+ parseNew(node) {
+ node.callee = this.parseNoCallExpr();
+
+ if (node.callee.type === "Import") {
+ this.raise(ErrorMessages.ImportCallNotNewExpression, {
+ node: node.callee
+ });
+ } else if (this.isOptionalChain(node.callee)) {
+ this.raise(ErrorMessages.OptionalChainingNoNew, {
+ at: this.state.lastTokEndLoc
+ });
+ } else if (this.eat(18)) {
+ this.raise(ErrorMessages.OptionalChainingNoNew, {
+ at: this.state.startLoc
+ });
+ }
+
+ this.parseNewArguments(node);
+ return this.finishNode(node, "NewExpression");
+ }
+
+ parseNewArguments(node) {
+ if (this.eat(10)) {
+ const args = this.parseExprList(11);
+ this.toReferencedList(args);
+ node.arguments = args;
+ } else {
+ node.arguments = [];
+ }
+ }
+
+ parseTemplateElement(isTagged) {
+ const {
+ start,
+ startLoc,
+ end,
+ value
+ } = this.state;
+ const elemStart = start + 1;
+ const elem = this.startNodeAt(elemStart, createPositionWithColumnOffset(startLoc, 1));
+
+ if (value === null) {
+ if (!isTagged) {
+ this.raise(ErrorMessages.InvalidEscapeSequenceTemplate, {
+ at: createPositionWithColumnOffset(startLoc, 2)
+ });
+ }
+ }
+
+ const isTail = this.match(24);
+ const endOffset = isTail ? -1 : -2;
+ const elemEnd = end + endOffset;
+ elem.value = {
+ raw: this.input.slice(elemStart, elemEnd).replace(/\r\n?/g, "\n"),
+ cooked: value === null ? null : value.slice(1, endOffset)
+ };
+ elem.tail = isTail;
+ this.next();
+ this.finishNode(elem, "TemplateElement");
+ this.resetEndLocation(elem, createPositionWithColumnOffset(this.state.lastTokEndLoc, endOffset));
+ return elem;
+ }
+
+ parseTemplate(isTagged) {
+ const node = this.startNode();
+ node.expressions = [];
+ let curElt = this.parseTemplateElement(isTagged);
+ node.quasis = [curElt];
+
+ while (!curElt.tail) {
+ node.expressions.push(this.parseTemplateSubstitution());
+ this.readTemplateContinuation();
+ node.quasis.push(curElt = this.parseTemplateElement(isTagged));
+ }
+
+ return this.finishNode(node, "TemplateLiteral");
+ }
+
+ parseTemplateSubstitution() {
+ return this.parseExpression();
+ }
+
+ parseObjectLike(close, isPattern, isRecord, refExpressionErrors) {
+ if (isRecord) {
+ this.expectPlugin("recordAndTuple");
+ }
+
+ const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;
+ this.state.inFSharpPipelineDirectBody = false;
+ const propHash = Object.create(null);
+ let first = true;
+ const node = this.startNode();
+ node.properties = [];
+ this.next();
+
+ while (!this.match(close)) {
+ if (first) {
+ first = false;
+ } else {
+ this.expect(12);
+
+ if (this.match(close)) {
+ this.addTrailingCommaExtraToNode(node);
+ break;
+ }
+ }
+
+ let prop;
+
+ if (isPattern) {
+ prop = this.parseBindingProperty();
+ } else {
+ prop = this.parsePropertyDefinition(refExpressionErrors);
+ this.checkProto(prop, isRecord, propHash, refExpressionErrors);
+ }
+
+ if (isRecord && !this.isObjectProperty(prop) && prop.type !== "SpreadElement") {
+ this.raise(ErrorMessages.InvalidRecordProperty, {
+ node: prop
+ });
+ }
+
+ if (prop.shorthand) {
+ this.addExtra(prop, "shorthand", true);
+ }
+
+ node.properties.push(prop);
+ }
+
+ this.next();
+ this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;
+ let type = "ObjectExpression";
+
+ if (isPattern) {
+ type = "ObjectPattern";
+ } else if (isRecord) {
+ type = "RecordExpression";
+ }
+
+ return this.finishNode(node, type);
+ }
+
+ addTrailingCommaExtraToNode(node) {
+ this.addExtra(node, "trailingComma", this.state.lastTokStart);
+ this.addExtra(node, "trailingCommaLoc", this.state.lastTokStartLoc, false);
+ }
+
+ maybeAsyncOrAccessorProp(prop) {
+ return !prop.computed && prop.key.type === "Identifier" && (this.isLiteralPropertyName() || this.match(0) || this.match(55));
+ }
+
+ parsePropertyDefinition(refExpressionErrors) {
+ let decorators = [];
+
+ if (this.match(26)) {
+ if (this.hasPlugin("decorators")) {
+ this.raise(ErrorMessages.UnsupportedPropertyDecorator, {
+ at: this.state.startLoc
+ });
+ }
+
+ while (this.match(26)) {
+ decorators.push(this.parseDecorator());
+ }
+ }
+
+ const prop = this.startNode();
+ let isAsync = false;
+ let isAccessor = false;
+ let startPos;
+ let startLoc;
+
+ if (this.match(21)) {
+ if (decorators.length) this.unexpected();
+ return this.parseSpread();
+ }
+
+ if (decorators.length) {
+ prop.decorators = decorators;
+ decorators = [];
+ }
+
+ prop.method = false;
+
+ if (refExpressionErrors) {
+ startPos = this.state.start;
+ startLoc = this.state.startLoc;
+ }
+
+ let isGenerator = this.eat(55);
+ this.parsePropertyNamePrefixOperator(prop);
+ const containsEsc = this.state.containsEsc;
+ const key = this.parsePropertyName(prop, refExpressionErrors);
+
+ if (!isGenerator && !containsEsc && this.maybeAsyncOrAccessorProp(prop)) {
+ const keyName = key.name;
+
+ if (keyName === "async" && !this.hasPrecedingLineBreak()) {
+ isAsync = true;
+ this.resetPreviousNodeTrailingComments(key);
+ isGenerator = this.eat(55);
+ this.parsePropertyName(prop);
+ }
+
+ if (keyName === "get" || keyName === "set") {
+ isAccessor = true;
+ this.resetPreviousNodeTrailingComments(key);
+ prop.kind = keyName;
+
+ if (this.match(55)) {
+ isGenerator = true;
+ this.raise(ErrorMessages.AccessorIsGenerator, {
+ at: this.state.curPosition()
+ }, keyName);
+ this.next();
+ }
+
+ this.parsePropertyName(prop);
+ }
+ }
+
+ this.parseObjPropValue(prop, startPos, startLoc, isGenerator, isAsync, false, isAccessor, refExpressionErrors);
+ return prop;
+ }
+
+ getGetterSetterExpectedParamCount(method) {
+ return method.kind === "get" ? 0 : 1;
+ }
+
+ getObjectOrClassMethodParams(method) {
+ return method.params;
+ }
+
+ checkGetterSetterParams(method) {
+ var _params;
+
+ const paramCount = this.getGetterSetterExpectedParamCount(method);
+ const params = this.getObjectOrClassMethodParams(method);
+
+ if (params.length !== paramCount) {
+ this.raise(method.kind === "get" ? ErrorMessages.BadGetterArity : ErrorMessages.BadSetterArity, {
+ node: method
+ });
+ }
+
+ if (method.kind === "set" && ((_params = params[params.length - 1]) == null ? void 0 : _params.type) === "RestElement") {
+ this.raise(ErrorMessages.BadSetterRestParameter, {
+ node: method
+ });
+ }
+ }
+
+ parseObjectMethod(prop, isGenerator, isAsync, isPattern, isAccessor) {
+ if (isAccessor) {
+ this.parseMethod(prop, isGenerator, false, false, false, "ObjectMethod");
+ this.checkGetterSetterParams(prop);
+ return prop;
+ }
+
+ if (isAsync || isGenerator || this.match(10)) {
+ if (isPattern) this.unexpected();
+ prop.kind = "method";
+ prop.method = true;
+ return this.parseMethod(prop, isGenerator, isAsync, false, false, "ObjectMethod");
+ }
+ }
+
+ parseObjectProperty(prop, startPos, startLoc, isPattern, refExpressionErrors) {
+ prop.shorthand = false;
+
+ if (this.eat(14)) {
+ prop.value = isPattern ? this.parseMaybeDefault(this.state.start, this.state.startLoc) : this.parseMaybeAssignAllowIn(refExpressionErrors);
+ return this.finishNode(prop, "ObjectProperty");
+ }
+
+ if (!prop.computed && prop.key.type === "Identifier") {
+ this.checkReservedWord(prop.key.name, prop.key.loc.start, true, false);
+
+ if (isPattern) {
+ prop.value = this.parseMaybeDefault(startPos, startLoc, cloneIdentifier(prop.key));
+ } else if (this.match(29)) {
+ const shorthandAssignLoc = this.state.startLoc;
+
+ if (refExpressionErrors != null) {
+ if (refExpressionErrors.shorthandAssignLoc === null) {
+ refExpressionErrors.shorthandAssignLoc = shorthandAssignLoc;
+ }
+ } else {
+ this.raise(ErrorMessages.InvalidCoverInitializedName, {
+ at: shorthandAssignLoc
+ });
+ }
+
+ prop.value = this.parseMaybeDefault(startPos, startLoc, cloneIdentifier(prop.key));
+ } else {
+ prop.value = cloneIdentifier(prop.key);
+ }
+
+ prop.shorthand = true;
+ return this.finishNode(prop, "ObjectProperty");
+ }
+ }
+
+ parseObjPropValue(prop, startPos, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors) {
+ const node = this.parseObjectMethod(prop, isGenerator, isAsync, isPattern, isAccessor) || this.parseObjectProperty(prop, startPos, startLoc, isPattern, refExpressionErrors);
+ if (!node) this.unexpected();
+ return node;
+ }
+
+ parsePropertyName(prop, refExpressionErrors) {
+ if (this.eat(0)) {
+ prop.computed = true;
+ prop.key = this.parseMaybeAssignAllowIn();
+ this.expect(3);
+ } else {
+ const {
+ type,
+ value
+ } = this.state;
+ let key;
+
+ if (tokenIsKeywordOrIdentifier(type)) {
+ key = this.parseIdentifier(true);
+ } else {
+ switch (type) {
+ case 130:
+ key = this.parseNumericLiteral(value);
+ break;
+
+ case 129:
+ key = this.parseStringLiteral(value);
+ break;
+
+ case 131:
+ key = this.parseBigIntLiteral(value);
+ break;
+
+ case 132:
+ key = this.parseDecimalLiteral(value);
+ break;
+
+ case 134:
+ {
+ const privateKeyLoc = this.state.startLoc;
+
+ if (refExpressionErrors != null) {
+ if (refExpressionErrors.privateKeyLoc === null) {
+ refExpressionErrors.privateKeyLoc = privateKeyLoc;
+ }
+ } else {
+ this.raise(ErrorMessages.UnexpectedPrivateField, {
+ at: privateKeyLoc
+ });
+ }
+
+ key = this.parsePrivateName();
+ break;
+ }
+
+ default:
+ throw this.unexpected();
+ }
+ }
+
+ prop.key = key;
+
+ if (type !== 134) {
+ prop.computed = false;
+ }
+ }
+
+ return prop.key;
+ }
+
+ initFunction(node, isAsync) {
+ node.id = null;
+ node.generator = false;
+ node.async = !!isAsync;
+ }
+
+ parseMethod(node, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope = false) {
+ this.initFunction(node, isAsync);
+ node.generator = !!isGenerator;
+ const allowModifiers = isConstructor;
+ this.scope.enter(SCOPE_FUNCTION | SCOPE_SUPER | (inClassScope ? SCOPE_CLASS : 0) | (allowDirectSuper ? SCOPE_DIRECT_SUPER : 0));
+ this.prodParam.enter(functionFlags(isAsync, node.generator));
+ this.parseFunctionParams(node, allowModifiers);
+ this.parseFunctionBodyAndFinish(node, type, true);
+ this.prodParam.exit();
+ this.scope.exit();
+ return node;
+ }
+
+ parseArrayLike(close, canBePattern, isTuple, refExpressionErrors) {
+ if (isTuple) {
+ this.expectPlugin("recordAndTuple");
+ }
+
+ const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;
+ this.state.inFSharpPipelineDirectBody = false;
+ const node = this.startNode();
+ this.next();
+ node.elements = this.parseExprList(close, !isTuple, refExpressionErrors, node);
+ this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;
+ return this.finishNode(node, isTuple ? "TupleExpression" : "ArrayExpression");
+ }
+
+ parseArrowExpression(node, params, isAsync, trailingCommaLoc) {
+ this.scope.enter(SCOPE_FUNCTION | SCOPE_ARROW);
+ let flags = functionFlags(isAsync, false);
+
+ if (!this.match(5) && this.prodParam.hasIn) {
+ flags |= PARAM_IN;
+ }
+
+ this.prodParam.enter(flags);
+ this.initFunction(node, isAsync);
+ const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;
+
+ if (params) {
+ this.state.maybeInArrowParameters = true;
+ this.setArrowFunctionParameters(node, params, trailingCommaLoc);
+ }
+
+ this.state.maybeInArrowParameters = false;
+ this.parseFunctionBody(node, true);
+ this.prodParam.exit();
+ this.scope.exit();
+ this.state.maybeInArrowParameters = oldMaybeInArrowParameters;
+ return this.finishNode(node, "ArrowFunctionExpression");
+ }
+
+ setArrowFunctionParameters(node, params, trailingCommaLoc) {
+ node.params = this.toAssignableList(params, trailingCommaLoc, false);
+ }
+
+ parseFunctionBodyAndFinish(node, type, isMethod = false) {
+ this.parseFunctionBody(node, false, isMethod);
+ this.finishNode(node, type);
+ }
+
+ parseFunctionBody(node, allowExpression, isMethod = false) {
+ const isExpression = allowExpression && !this.match(5);
+ this.expressionScope.enter(newExpressionScope());
+
+ if (isExpression) {
+ node.body = this.parseMaybeAssign();
+ this.checkParams(node, false, allowExpression, false);
+ } else {
+ const oldStrict = this.state.strict;
+ const oldLabels = this.state.labels;
+ this.state.labels = [];
+ this.prodParam.enter(this.prodParam.currentFlags() | PARAM_RETURN);
+ node.body = this.parseBlock(true, false, hasStrictModeDirective => {
+ const nonSimple = !this.isSimpleParamList(node.params);
+
+ if (hasStrictModeDirective && nonSimple) {
+ const errorOrigin = (node.kind === "method" || node.kind === "constructor") && !!node.key ? {
+ at: node.key.loc.end
+ } : {
+ node
+ };
+ this.raise(ErrorMessages.IllegalLanguageModeDirective, errorOrigin);
+ }
+
+ const strictModeChanged = !oldStrict && this.state.strict;
+ this.checkParams(node, !this.state.strict && !allowExpression && !isMethod && !nonSimple, allowExpression, strictModeChanged);
+
+ if (this.state.strict && node.id) {
+ this.checkLVal(node.id, "function name", BIND_OUTSIDE, undefined, undefined, strictModeChanged);
+ }
+ });
+ this.prodParam.exit();
+ this.state.labels = oldLabels;
+ }
+
+ this.expressionScope.exit();
+ }
+
+ isSimpleParamList(params) {
+ for (let i = 0, len = params.length; i < len; i++) {
+ if (params[i].type !== "Identifier") return false;
+ }
+
+ return true;
+ }
+
+ checkParams(node, allowDuplicates, isArrowFunction, strictModeChanged = true) {
+ const checkClashes = new Set();
+
+ for (const param of node.params) {
+ this.checkLVal(param, "function parameter list", BIND_VAR, allowDuplicates ? null : checkClashes, undefined, strictModeChanged);
+ }
+ }
+
+ parseExprList(close, allowEmpty, refExpressionErrors, nodeForExtra) {
+ const elts = [];
+ let first = true;
+
+ while (!this.eat(close)) {
+ if (first) {
+ first = false;
+ } else {
+ this.expect(12);
+
+ if (this.match(close)) {
+ if (nodeForExtra) {
+ this.addTrailingCommaExtraToNode(nodeForExtra);
+ }
+
+ this.next();
+ break;
+ }
+ }
+
+ elts.push(this.parseExprListItem(allowEmpty, refExpressionErrors));
+ }
+
+ return elts;
+ }
+
+ parseExprListItem(allowEmpty, refExpressionErrors, allowPlaceholder) {
+ let elt;
+
+ if (this.match(12)) {
+ if (!allowEmpty) {
+ this.raise(ErrorMessages.UnexpectedToken, {
+ at: this.state.curPosition()
+ }, ",");
+ }
+
+ elt = null;
+ } else if (this.match(21)) {
+ const spreadNodeStartPos = this.state.start;
+ const spreadNodeStartLoc = this.state.startLoc;
+ elt = this.parseParenItem(this.parseSpread(refExpressionErrors), spreadNodeStartPos, spreadNodeStartLoc);
+ } else if (this.match(17)) {
+ this.expectPlugin("partialApplication");
+
+ if (!allowPlaceholder) {
+ this.raise(ErrorMessages.UnexpectedArgumentPlaceholder, {
+ at: this.state.startLoc
+ });
+ }
+
+ const node = this.startNode();
+ this.next();
+ elt = this.finishNode(node, "ArgumentPlaceholder");
+ } else {
+ elt = this.parseMaybeAssignAllowIn(refExpressionErrors, this.parseParenItem);
+ }
+
+ return elt;
+ }
+
+ parseIdentifier(liberal) {
+ const node = this.startNode();
+ const name = this.parseIdentifierName(node.start, liberal);
+ return this.createIdentifier(node, name);
+ }
+
+ createIdentifier(node, name) {
+ node.name = name;
+ node.loc.identifierName = name;
+ return this.finishNode(node, "Identifier");
+ }
+
+ parseIdentifierName(pos, liberal) {
+ let name;
+ const {
+ startLoc,
+ type
+ } = this.state;
+
+ if (tokenIsKeywordOrIdentifier(type)) {
+ name = this.state.value;
+ } else {
+ throw this.unexpected();
+ }
+
+ const tokenIsKeyword = tokenKeywordOrIdentifierIsKeyword(type);
+
+ if (liberal) {
+ if (tokenIsKeyword) {
+ this.replaceToken(128);
+ }
+ } else {
+ this.checkReservedWord(name, startLoc, tokenIsKeyword, false);
+ }
+
+ this.next();
+ return name;
+ }
+
+ checkReservedWord(word, startLoc, checkKeywords, isBinding) {
+ if (word.length > 10) {
+ return;
+ }
+
+ if (!canBeReservedWord(word)) {
+ return;
+ }
+
+ if (word === "yield") {
+ if (this.prodParam.hasYield) {
+ this.raise(ErrorMessages.YieldBindingIdentifier, {
+ at: startLoc
+ });
+ return;
+ }
+ } else if (word === "await") {
+ if (this.prodParam.hasAwait) {
+ this.raise(ErrorMessages.AwaitBindingIdentifier, {
+ at: startLoc
+ });
+ return;
+ }
+
+ if (this.scope.inStaticBlock) {
+ this.raise(ErrorMessages.AwaitBindingIdentifierInStaticBlock, {
+ at: startLoc
+ });
+ return;
+ }
+
+ this.expressionScope.recordAsyncArrowParametersError(ErrorMessages.AwaitBindingIdentifier, startLoc);
+ } else if (word === "arguments") {
+ if (this.scope.inClassAndNotInNonArrowFunction) {
+ this.raise(ErrorMessages.ArgumentsInClass, {
+ at: startLoc
+ });
+ return;
+ }
+ }
+
+ if (checkKeywords && isKeyword(word)) {
+ this.raise(ErrorMessages.UnexpectedKeyword, {
+ at: startLoc
+ }, word);
+ return;
+ }
+
+ const reservedTest = !this.state.strict ? isReservedWord : isBinding ? isStrictBindReservedWord : isStrictReservedWord;
+
+ if (reservedTest(word, this.inModule)) {
+ this.raise(ErrorMessages.UnexpectedReservedWord, {
+ at: startLoc
+ }, word);
+ }
+ }
+
+ isAwaitAllowed() {
+ if (this.prodParam.hasAwait) return true;
+
+ if (this.options.allowAwaitOutsideFunction && !this.scope.inFunction) {
+ return true;
+ }
+
+ return false;
+ }
+
+ parseAwait(startPos, startLoc) {
+ const node = this.startNodeAt(startPos, startLoc);
+ this.expressionScope.recordParameterInitializerError(node.loc.start, ErrorMessages.AwaitExpressionFormalParameter);
+
+ if (this.eat(55)) {
+ this.raise(ErrorMessages.ObsoleteAwaitStar, {
+ node
+ });
+ }
+
+ if (!this.scope.inFunction && !this.options.allowAwaitOutsideFunction) {
+ if (this.isAmbiguousAwait()) {
+ this.ambiguousScriptDifferentAst = true;
+ } else {
+ this.sawUnambiguousESM = true;
+ }
+ }
+
+ if (!this.state.soloAwait) {
+ node.argument = this.parseMaybeUnary(null, true);
+ }
+
+ return this.finishNode(node, "AwaitExpression");
+ }
+
+ isAmbiguousAwait() {
+ if (this.hasPrecedingLineBreak()) return true;
+ const {
+ type
+ } = this.state;
+ return type === 53 || type === 10 || type === 0 || tokenIsTemplate(type) || type === 133 || type === 56 || this.hasPlugin("v8intrinsic") && type === 54;
+ }
+
+ parseYield() {
+ const node = this.startNode();
+ this.expressionScope.recordParameterInitializerError(node.loc.start, ErrorMessages.YieldInParameter);
+ this.next();
+ let delegating = false;
+ let argument = null;
+
+ if (!this.hasPrecedingLineBreak()) {
+ delegating = this.eat(55);
+
+ switch (this.state.type) {
+ case 13:
+ case 135:
+ case 8:
+ case 11:
+ case 3:
+ case 9:
+ case 14:
+ case 12:
+ if (!delegating) break;
+
+ default:
+ argument = this.parseMaybeAssign();
+ }
+ }
+
+ node.delegate = delegating;
+ node.argument = argument;
+ return this.finishNode(node, "YieldExpression");
+ }
+
+ checkPipelineAtInfixOperator(left, leftStartLoc) {
+ if (this.hasPlugin(["pipelineOperator", {
+ proposal: "smart"
+ }])) {
+ if (left.type === "SequenceExpression") {
+ this.raise(ErrorMessages.PipelineHeadSequenceExpression, {
+ at: leftStartLoc
+ });
+ }
+ }
+ }
+
+ parseSmartPipelineBodyInStyle(childExpr, startPos, startLoc) {
+ const bodyNode = this.startNodeAt(startPos, startLoc);
+
+ if (this.isSimpleReference(childExpr)) {
+ bodyNode.callee = childExpr;
+ return this.finishNode(bodyNode, "PipelineBareFunction");
+ } else {
+ this.checkSmartPipeTopicBodyEarlyErrors(startLoc);
+ bodyNode.expression = childExpr;
+ return this.finishNode(bodyNode, "PipelineTopicExpression");
+ }
+ }
+
+ isSimpleReference(expression) {
+ switch (expression.type) {
+ case "MemberExpression":
+ return !expression.computed && this.isSimpleReference(expression.object);
+
+ case "Identifier":
+ return true;
+
+ default:
+ return false;
+ }
+ }
+
+ checkSmartPipeTopicBodyEarlyErrors(startLoc) {
+ if (this.match(19)) {
+ throw this.raise(ErrorMessages.PipelineBodyNoArrow, {
+ at: this.state.startLoc
+ });
+ }
+
+ if (!this.topicReferenceWasUsedInCurrentContext()) {
+ this.raise(ErrorMessages.PipelineTopicUnused, {
+ at: startLoc
+ });
+ }
+ }
+
+ withTopicBindingContext(callback) {
+ const outerContextTopicState = this.state.topicContext;
+ this.state.topicContext = {
+ maxNumOfResolvableTopics: 1,
+ maxTopicIndex: null
+ };
+
+ try {
+ return callback();
+ } finally {
+ this.state.topicContext = outerContextTopicState;
+ }
+ }
+
+ withSmartMixTopicForbiddingContext(callback) {
+ if (this.hasPlugin(["pipelineOperator", {
+ proposal: "smart"
+ }])) {
+ const outerContextTopicState = this.state.topicContext;
+ this.state.topicContext = {
+ maxNumOfResolvableTopics: 0,
+ maxTopicIndex: null
+ };
+
+ try {
+ return callback();
+ } finally {
+ this.state.topicContext = outerContextTopicState;
+ }
+ } else {
+ return callback();
+ }
+ }
+
+ withSoloAwaitPermittingContext(callback) {
+ const outerContextSoloAwaitState = this.state.soloAwait;
+ this.state.soloAwait = true;
+
+ try {
+ return callback();
+ } finally {
+ this.state.soloAwait = outerContextSoloAwaitState;
+ }
+ }
+
+ allowInAnd(callback) {
+ const flags = this.prodParam.currentFlags();
+ const prodParamToSet = PARAM_IN & ~flags;
+
+ if (prodParamToSet) {
+ this.prodParam.enter(flags | PARAM_IN);
+
+ try {
+ return callback();
+ } finally {
+ this.prodParam.exit();
+ }
+ }
+
+ return callback();
+ }
+
+ disallowInAnd(callback) {
+ const flags = this.prodParam.currentFlags();
+ const prodParamToClear = PARAM_IN & flags;
+
+ if (prodParamToClear) {
+ this.prodParam.enter(flags & ~PARAM_IN);
+
+ try {
+ return callback();
+ } finally {
+ this.prodParam.exit();
+ }
+ }
+
+ return callback();
+ }
+
+ registerTopicReference() {
+ this.state.topicContext.maxTopicIndex = 0;
+ }
+
+ topicReferenceIsAllowedInCurrentContext() {
+ return this.state.topicContext.maxNumOfResolvableTopics >= 1;
+ }
+
+ topicReferenceWasUsedInCurrentContext() {
+ return this.state.topicContext.maxTopicIndex != null && this.state.topicContext.maxTopicIndex >= 0;
+ }
+
+ parseFSharpPipelineBody(prec) {
+ const startPos = this.state.start;
+ const startLoc = this.state.startLoc;
+ this.state.potentialArrowAt = this.state.start;
+ const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;
+ this.state.inFSharpPipelineDirectBody = true;
+ const ret = this.parseExprOp(this.parseMaybeUnaryOrPrivate(), startPos, startLoc, prec);
+ this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;
+ return ret;
+ }
+
+ parseModuleExpression() {
+ this.expectPlugin("moduleBlocks");
+ const node = this.startNode();
+ this.next();
+ this.eat(5);
+ const revertScopes = this.initializeScopes(true);
+ this.enterInitialScopes();
+ const program = this.startNode();
+
+ try {
+ node.body = this.parseProgram(program, 8, "module");
+ } finally {
+ revertScopes();
+ }
+
+ this.eat(8);
+ return this.finishNode(node, "ModuleExpression");
+ }
+
+ parsePropertyNamePrefixOperator(prop) {}
+
+}
+
+const loopLabel = {
+ kind: "loop"
+},
+ switchLabel = {
+ kind: "switch"
+};
+const FUNC_NO_FLAGS = 0b000,
+ FUNC_STATEMENT = 0b001,
+ FUNC_HANGING_STATEMENT = 0b010,
+ FUNC_NULLABLE_ID = 0b100;
+const loneSurrogate = /[\uD800-\uDFFF]/u;
+const keywordRelationalOperator = /in(?:stanceof)?/y;
+
+function babel7CompatTokens(tokens, input) {
+ for (let i = 0; i < tokens.length; i++) {
+ const token = tokens[i];
+ const {
+ type
+ } = token;
+
+ if (typeof type === "number") {
+ {
+ if (type === 134) {
+ const {
+ loc,
+ start,
+ value,
+ end
+ } = token;
+ const hashEndPos = start + 1;
+ const hashEndLoc = createPositionWithColumnOffset(loc.start, 1);
+ tokens.splice(i, 1, new Token({
+ type: getExportedToken(27),
+ value: "#",
+ start: start,
+ end: hashEndPos,
+ startLoc: loc.start,
+ endLoc: hashEndLoc
+ }), new Token({
+ type: getExportedToken(128),
+ value: value,
+ start: hashEndPos,
+ end: end,
+ startLoc: hashEndLoc,
+ endLoc: loc.end
+ }));
+ i++;
+ continue;
+ }
+
+ if (tokenIsTemplate(type)) {
+ const {
+ loc,
+ start,
+ value,
+ end
+ } = token;
+ const backquoteEnd = start + 1;
+ const backquoteEndLoc = createPositionWithColumnOffset(loc.start, 1);
+ let startToken;
+
+ if (input.charCodeAt(start) === 96) {
+ startToken = new Token({
+ type: getExportedToken(22),
+ value: "`",
+ start: start,
+ end: backquoteEnd,
+ startLoc: loc.start,
+ endLoc: backquoteEndLoc
+ });
+ } else {
+ startToken = new Token({
+ type: getExportedToken(8),
+ value: "}",
+ start: start,
+ end: backquoteEnd,
+ startLoc: loc.start,
+ endLoc: backquoteEndLoc
+ });
+ }
+
+ let templateValue, templateElementEnd, templateElementEndLoc, endToken;
+
+ if (type === 24) {
+ templateElementEnd = end - 1;
+ templateElementEndLoc = createPositionWithColumnOffset(loc.end, -1);
+ templateValue = value === null ? null : value.slice(1, -1);
+ endToken = new Token({
+ type: getExportedToken(22),
+ value: "`",
+ start: templateElementEnd,
+ end: end,
+ startLoc: templateElementEndLoc,
+ endLoc: loc.end
+ });
+ } else {
+ templateElementEnd = end - 2;
+ templateElementEndLoc = createPositionWithColumnOffset(loc.end, -2);
+ templateValue = value === null ? null : value.slice(1, -2);
+ endToken = new Token({
+ type: getExportedToken(23),
+ value: "${",
+ start: templateElementEnd,
+ end: end,
+ startLoc: templateElementEndLoc,
+ endLoc: loc.end
+ });
+ }
+
+ tokens.splice(i, 1, startToken, new Token({
+ type: getExportedToken(20),
+ value: templateValue,
+ start: backquoteEnd,
+ end: templateElementEnd,
+ startLoc: backquoteEndLoc,
+ endLoc: templateElementEndLoc
+ }), endToken);
+ i += 2;
+ continue;
+ }
+ }
+ token.type = getExportedToken(type);
+ }
+ }
+
+ return tokens;
+}
+
+class StatementParser extends ExpressionParser {
+ parseTopLevel(file, program) {
+ file.program = this.parseProgram(program);
+ file.comments = this.state.comments;
+
+ if (this.options.tokens) {
+ file.tokens = babel7CompatTokens(this.tokens, this.input);
+ }
+
+ return this.finishNode(file, "File");
+ }
+
+ parseProgram(program, end = 135, sourceType = this.options.sourceType) {
+ program.sourceType = sourceType;
+ program.interpreter = this.parseInterpreterDirective();
+ this.parseBlockBody(program, true, true, end);
+
+ if (this.inModule && !this.options.allowUndeclaredExports && this.scope.undefinedExports.size > 0) {
+ for (const [name, loc] of Array.from(this.scope.undefinedExports)) {
+ this.raise(ErrorMessages.ModuleExportUndefined, {
+ at: loc
+ }, name);
+ }
+ }
+
+ return this.finishNode(program, "Program");
+ }
+
+ stmtToDirective(stmt) {
+ const directive = stmt;
+ directive.type = "Directive";
+ directive.value = directive.expression;
+ delete directive.expression;
+ const directiveLiteral = directive.value;
+ const expressionValue = directiveLiteral.value;
+ const raw = this.input.slice(directiveLiteral.start, directiveLiteral.end);
+ const val = directiveLiteral.value = raw.slice(1, -1);
+ this.addExtra(directiveLiteral, "raw", raw);
+ this.addExtra(directiveLiteral, "rawValue", val);
+ this.addExtra(directiveLiteral, "expressionValue", expressionValue);
+ directiveLiteral.type = "DirectiveLiteral";
+ return directive;
+ }
+
+ parseInterpreterDirective() {
+ if (!this.match(28)) {
+ return null;
+ }
+
+ const node = this.startNode();
+ node.value = this.state.value;
+ this.next();
+ return this.finishNode(node, "InterpreterDirective");
+ }
+
+ isLet(context) {
+ if (!this.isContextual(99)) {
+ return false;
+ }
+
+ return this.isLetKeyword(context);
+ }
+
+ isLetKeyword(context) {
+ const next = this.nextTokenStart();
+ const nextCh = this.codePointAtPos(next);
+
+ if (nextCh === 92 || nextCh === 91) {
+ return true;
+ }
+
+ if (context) return false;
+ if (nextCh === 123) return true;
+
+ if (isIdentifierStart(nextCh)) {
+ keywordRelationalOperator.lastIndex = next;
+
+ if (keywordRelationalOperator.test(this.input)) {
+ const endCh = this.codePointAtPos(keywordRelationalOperator.lastIndex);
+
+ if (!isIdentifierChar(endCh) && endCh !== 92) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ return false;
+ }
+
+ parseStatement(context, topLevel) {
+ if (this.match(26)) {
+ this.parseDecorators(true);
+ }
+
+ return this.parseStatementContent(context, topLevel);
+ }
+
+ parseStatementContent(context, topLevel) {
+ let starttype = this.state.type;
+ const node = this.startNode();
+ let kind;
+
+ if (this.isLet(context)) {
+ starttype = 74;
+ kind = "let";
+ }
+
+ switch (starttype) {
+ case 60:
+ return this.parseBreakContinueStatement(node, true);
+
+ case 63:
+ return this.parseBreakContinueStatement(node, false);
+
+ case 64:
+ return this.parseDebuggerStatement(node);
+
+ case 90:
+ return this.parseDoStatement(node);
+
+ case 91:
+ return this.parseForStatement(node);
+
+ case 68:
+ if (this.lookaheadCharCode() === 46) break;
+
+ if (context) {
+ if (this.state.strict) {
+ this.raise(ErrorMessages.StrictFunction, {
+ at: this.state.startLoc
+ });
+ } else if (context !== "if" && context !== "label") {
+ this.raise(ErrorMessages.SloppyFunction, {
+ at: this.state.startLoc
+ });
+ }
+ }
+
+ return this.parseFunctionStatement(node, false, !context);
+
+ case 80:
+ if (context) this.unexpected();
+ return this.parseClass(node, true);
+
+ case 69:
+ return this.parseIfStatement(node);
+
+ case 70:
+ return this.parseReturnStatement(node);
+
+ case 71:
+ return this.parseSwitchStatement(node);
+
+ case 72:
+ return this.parseThrowStatement(node);
+
+ case 73:
+ return this.parseTryStatement(node);
+
+ case 75:
+ case 74:
+ kind = kind || this.state.value;
+
+ if (context && kind !== "var") {
+ this.raise(ErrorMessages.UnexpectedLexicalDeclaration, {
+ at: this.state.startLoc
+ });
+ }
+
+ return this.parseVarStatement(node, kind);
+
+ case 92:
+ return this.parseWhileStatement(node);
+
+ case 76:
+ return this.parseWithStatement(node);
+
+ case 5:
+ return this.parseBlock();
+
+ case 13:
+ return this.parseEmptyStatement(node);
+
+ case 83:
+ {
+ const nextTokenCharCode = this.lookaheadCharCode();
+
+ if (nextTokenCharCode === 40 || nextTokenCharCode === 46) {
+ break;
+ }
+ }
+
+ case 82:
+ {
+ if (!this.options.allowImportExportEverywhere && !topLevel) {
+ this.raise(ErrorMessages.UnexpectedImportExport, {
+ at: this.state.startLoc
+ });
+ }
+
+ this.next();
+ let result;
+
+ if (starttype === 83) {
+ result = this.parseImport(node);
+
+ if (result.type === "ImportDeclaration" && (!result.importKind || result.importKind === "value")) {
+ this.sawUnambiguousESM = true;
+ }
+ } else {
+ result = this.parseExport(node);
+
+ if (result.type === "ExportNamedDeclaration" && (!result.exportKind || result.exportKind === "value") || result.type === "ExportAllDeclaration" && (!result.exportKind || result.exportKind === "value") || result.type === "ExportDefaultDeclaration") {
+ this.sawUnambiguousESM = true;
+ }
+ }
+
+ this.assertModuleNodeAllowed(node);
+ return result;
+ }
+
+ default:
+ {
+ if (this.isAsyncFunction()) {
+ if (context) {
+ this.raise(ErrorMessages.AsyncFunctionInSingleStatementContext, {
+ at: this.state.startLoc
+ });
+ }
+
+ this.next();
+ return this.parseFunctionStatement(node, true, !context);
+ }
+ }
+ }
+
+ const maybeName = this.state.value;
+ const expr = this.parseExpression();
+
+ if (tokenIsIdentifier(starttype) && expr.type === "Identifier" && this.eat(14)) {
+ return this.parseLabeledStatement(node, maybeName, expr, context);
+ } else {
+ return this.parseExpressionStatement(node, expr);
+ }
+ }
+
+ assertModuleNodeAllowed(node) {
+ if (!this.options.allowImportExportEverywhere && !this.inModule) {
+ this.raise(SourceTypeModuleErrorMessages.ImportOutsideModule, {
+ node
+ });
+ }
+ }
+
+ takeDecorators(node) {
+ const decorators = this.state.decoratorStack[this.state.decoratorStack.length - 1];
+
+ if (decorators.length) {
+ node.decorators = decorators;
+ this.resetStartLocationFromNode(node, decorators[0]);
+ this.state.decoratorStack[this.state.decoratorStack.length - 1] = [];
+ }
+ }
+
+ canHaveLeadingDecorator() {
+ return this.match(80);
+ }
+
+ parseDecorators(allowExport) {
+ const currentContextDecorators = this.state.decoratorStack[this.state.decoratorStack.length - 1];
+
+ while (this.match(26)) {
+ const decorator = this.parseDecorator();
+ currentContextDecorators.push(decorator);
+ }
+
+ if (this.match(82)) {
+ if (!allowExport) {
+ this.unexpected();
+ }
+
+ if (this.hasPlugin("decorators") && !this.getPluginOption("decorators", "decoratorsBeforeExport")) {
+ this.raise(ErrorMessages.DecoratorExportClass, {
+ at: this.state.startLoc
+ });
+ }
+ } else if (!this.canHaveLeadingDecorator()) {
+ throw this.raise(ErrorMessages.UnexpectedLeadingDecorator, {
+ at: this.state.startLoc
+ });
+ }
+ }
+
+ parseDecorator() {
+ this.expectOnePlugin(["decorators-legacy", "decorators"]);
+ const node = this.startNode();
+ this.next();
+
+ if (this.hasPlugin("decorators")) {
+ this.state.decoratorStack.push([]);
+ const startPos = this.state.start;
+ const startLoc = this.state.startLoc;
+ let expr;
+
+ if (this.eat(10)) {
+ expr = this.parseExpression();
+ this.expect(11);
+ } else {
+ expr = this.parseIdentifier(false);
+
+ while (this.eat(16)) {
+ const node = this.startNodeAt(startPos, startLoc);
+ node.object = expr;
+ node.property = this.parseIdentifier(true);
+ node.computed = false;
+ expr = this.finishNode(node, "MemberExpression");
+ }
+ }
+
+ node.expression = this.parseMaybeDecoratorArguments(expr);
+ this.state.decoratorStack.pop();
+ } else {
+ node.expression = this.parseExprSubscripts();
+ }
+
+ return this.finishNode(node, "Decorator");
+ }
+
+ parseMaybeDecoratorArguments(expr) {
+ if (this.eat(10)) {
+ const node = this.startNodeAtNode(expr);
+ node.callee = expr;
+ node.arguments = this.parseCallExpressionArguments(11, false);
+ this.toReferencedList(node.arguments);
+ return this.finishNode(node, "CallExpression");
+ }
+
+ return expr;
+ }
+
+ parseBreakContinueStatement(node, isBreak) {
+ this.next();
+
+ if (this.isLineTerminator()) {
+ node.label = null;
+ } else {
+ node.label = this.parseIdentifier();
+ this.semicolon();
+ }
+
+ this.verifyBreakContinue(node, isBreak);
+ return this.finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement");
+ }
+
+ verifyBreakContinue(node, isBreak) {
+ let i;
+
+ for (i = 0; i < this.state.labels.length; ++i) {
+ const lab = this.state.labels[i];
+
+ if (node.label == null || lab.name === node.label.name) {
+ if (lab.kind != null && (isBreak || lab.kind === "loop")) break;
+ if (node.label && isBreak) break;
+ }
+ }
+
+ if (i === this.state.labels.length) {
+ this.raise(ErrorMessages.IllegalBreakContinue, {
+ node
+ }, isBreak ? "break" : "continue");
+ }
+ }
+
+ parseDebuggerStatement(node) {
+ this.next();
+ this.semicolon();
+ return this.finishNode(node, "DebuggerStatement");
+ }
+
+ parseHeaderExpression() {
+ this.expect(10);
+ const val = this.parseExpression();
+ this.expect(11);
+ return val;
+ }
+
+ parseDoStatement(node) {
+ this.next();
+ this.state.labels.push(loopLabel);
+ node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement("do"));
+ this.state.labels.pop();
+ this.expect(92);
+ node.test = this.parseHeaderExpression();
+ this.eat(13);
+ return this.finishNode(node, "DoWhileStatement");
+ }
+
+ parseForStatement(node) {
+ this.next();
+ this.state.labels.push(loopLabel);
+ let awaitAt = null;
+
+ if (this.isAwaitAllowed() && this.eatContextual(96)) {
+ awaitAt = this.state.lastTokStartLoc;
+ }
+
+ this.scope.enter(SCOPE_OTHER);
+ this.expect(10);
+
+ if (this.match(13)) {
+ if (awaitAt !== null) {
+ this.unexpected(awaitAt);
+ }
+
+ return this.parseFor(node, null);
+ }
+
+ const startsWithLet = this.isContextual(99);
+ const isLet = startsWithLet && this.isLetKeyword();
+
+ if (this.match(74) || this.match(75) || isLet) {
+ const init = this.startNode();
+ const kind = isLet ? "let" : this.state.value;
+ this.next();
+ this.parseVar(init, true, kind);
+ this.finishNode(init, "VariableDeclaration");
+
+ if ((this.match(58) || this.isContextual(101)) && init.declarations.length === 1) {
+ return this.parseForIn(node, init, awaitAt);
+ }
+
+ if (awaitAt !== null) {
+ this.unexpected(awaitAt);
+ }
+
+ return this.parseFor(node, init);
+ }
+
+ const startsWithAsync = this.isContextual(95);
+ const refExpressionErrors = new ExpressionErrors();
+ const init = this.parseExpression(true, refExpressionErrors);
+ const isForOf = this.isContextual(101);
+
+ if (isForOf) {
+ if (startsWithLet) {
+ this.raise(ErrorMessages.ForOfLet, {
+ node: init
+ });
+ }
+
+ if (awaitAt === null && startsWithAsync && init.type === "Identifier") {
+ this.raise(ErrorMessages.ForOfAsync, {
+ node: init
+ });
+ }
+ }
+
+ if (isForOf || this.match(58)) {
+ this.checkDestructuringPrivate(refExpressionErrors);
+ this.toAssignable(init, true);
+ const description = isForOf ? "for-of statement" : "for-in statement";
+ this.checkLVal(init, description);
+ return this.parseForIn(node, init, awaitAt);
+ } else {
+ this.checkExpressionErrors(refExpressionErrors, true);
+ }
+
+ if (awaitAt !== null) {
+ this.unexpected(awaitAt);
+ }
+
+ return this.parseFor(node, init);
+ }
+
+ parseFunctionStatement(node, isAsync, declarationPosition) {
+ this.next();
+ return this.parseFunction(node, FUNC_STATEMENT | (declarationPosition ? 0 : FUNC_HANGING_STATEMENT), isAsync);
+ }
+
+ parseIfStatement(node) {
+ this.next();
+ node.test = this.parseHeaderExpression();
+ node.consequent = this.parseStatement("if");
+ node.alternate = this.eat(66) ? this.parseStatement("if") : null;
+ return this.finishNode(node, "IfStatement");
+ }
+
+ parseReturnStatement(node) {
+ if (!this.prodParam.hasReturn && !this.options.allowReturnOutsideFunction) {
+ this.raise(ErrorMessages.IllegalReturn, {
+ at: this.state.startLoc
+ });
+ }
+
+ this.next();
+
+ if (this.isLineTerminator()) {
+ node.argument = null;
+ } else {
+ node.argument = this.parseExpression();
+ this.semicolon();
+ }
+
+ return this.finishNode(node, "ReturnStatement");
+ }
+
+ parseSwitchStatement(node) {
+ this.next();
+ node.discriminant = this.parseHeaderExpression();
+ const cases = node.cases = [];
+ this.expect(5);
+ this.state.labels.push(switchLabel);
+ this.scope.enter(SCOPE_OTHER);
+ let cur;
+
+ for (let sawDefault; !this.match(8);) {
+ if (this.match(61) || this.match(65)) {
+ const isCase = this.match(61);
+ if (cur) this.finishNode(cur, "SwitchCase");
+ cases.push(cur = this.startNode());
+ cur.consequent = [];
+ this.next();
+
+ if (isCase) {
+ cur.test = this.parseExpression();
+ } else {
+ if (sawDefault) {
+ this.raise(ErrorMessages.MultipleDefaultsInSwitch, {
+ at: this.state.lastTokStartLoc
+ });
+ }
+
+ sawDefault = true;
+ cur.test = null;
+ }
+
+ this.expect(14);
+ } else {
+ if (cur) {
+ cur.consequent.push(this.parseStatement(null));
+ } else {
+ this.unexpected();
+ }
+ }
+ }
+
+ this.scope.exit();
+ if (cur) this.finishNode(cur, "SwitchCase");
+ this.next();
+ this.state.labels.pop();
+ return this.finishNode(node, "SwitchStatement");
+ }
+
+ parseThrowStatement(node) {
+ this.next();
+
+ if (this.hasPrecedingLineBreak()) {
+ this.raise(ErrorMessages.NewlineAfterThrow, {
+ at: this.state.lastTokEndLoc
+ });
+ }
+
+ node.argument = this.parseExpression();
+ this.semicolon();
+ return this.finishNode(node, "ThrowStatement");
+ }
+
+ parseCatchClauseParam() {
+ const param = this.parseBindingAtom();
+ const simple = param.type === "Identifier";
+ this.scope.enter(simple ? SCOPE_SIMPLE_CATCH : 0);
+ this.checkLVal(param, "catch clause", BIND_LEXICAL);
+ return param;
+ }
+
+ parseTryStatement(node) {
+ this.next();
+ node.block = this.parseBlock();
+ node.handler = null;
+
+ if (this.match(62)) {
+ const clause = this.startNode();
+ this.next();
+
+ if (this.match(10)) {
+ this.expect(10);
+ clause.param = this.parseCatchClauseParam();
+ this.expect(11);
+ } else {
+ clause.param = null;
+ this.scope.enter(SCOPE_OTHER);
+ }
+
+ clause.body = this.withSmartMixTopicForbiddingContext(() => this.parseBlock(false, false));
+ this.scope.exit();
+ node.handler = this.finishNode(clause, "CatchClause");
+ }
+
+ node.finalizer = this.eat(67) ? this.parseBlock() : null;
+
+ if (!node.handler && !node.finalizer) {
+ this.raise(ErrorMessages.NoCatchOrFinally, {
+ node
+ });
+ }
+
+ return this.finishNode(node, "TryStatement");
+ }
+
+ parseVarStatement(node, kind) {
+ this.next();
+ this.parseVar(node, false, kind);
+ this.semicolon();
+ return this.finishNode(node, "VariableDeclaration");
+ }
+
+ parseWhileStatement(node) {
+ this.next();
+ node.test = this.parseHeaderExpression();
+ this.state.labels.push(loopLabel);
+ node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement("while"));
+ this.state.labels.pop();
+ return this.finishNode(node, "WhileStatement");
+ }
+
+ parseWithStatement(node) {
+ if (this.state.strict) {
+ this.raise(ErrorMessages.StrictWith, {
+ at: this.state.startLoc
+ });
+ }
+
+ this.next();
+ node.object = this.parseHeaderExpression();
+ node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement("with"));
+ return this.finishNode(node, "WithStatement");
+ }
+
+ parseEmptyStatement(node) {
+ this.next();
+ return this.finishNode(node, "EmptyStatement");
+ }
+
+ parseLabeledStatement(node, maybeName, expr, context) {
+ for (const label of this.state.labels) {
+ if (label.name === maybeName) {
+ this.raise(ErrorMessages.LabelRedeclaration, {
+ node: expr
+ }, maybeName);
+ }
+ }
+
+ const kind = tokenIsLoop(this.state.type) ? "loop" : this.match(71) ? "switch" : null;
+
+ for (let i = this.state.labels.length - 1; i >= 0; i--) {
+ const label = this.state.labels[i];
+
+ if (label.statementStart === node.start) {
+ label.statementStart = this.state.start;
+ label.kind = kind;
+ } else {
+ break;
+ }
+ }
+
+ this.state.labels.push({
+ name: maybeName,
+ kind: kind,
+ statementStart: this.state.start
+ });
+ node.body = this.parseStatement(context ? context.indexOf("label") === -1 ? context + "label" : context : "label");
+ this.state.labels.pop();
+ node.label = expr;
+ return this.finishNode(node, "LabeledStatement");
+ }
+
+ parseExpressionStatement(node, expr) {
+ node.expression = expr;
+ this.semicolon();
+ return this.finishNode(node, "ExpressionStatement");
+ }
+
+ parseBlock(allowDirectives = false, createNewLexicalScope = true, afterBlockParse) {
+ const node = this.startNode();
+
+ if (allowDirectives) {
+ this.state.strictErrors.clear();
+ }
+
+ this.expect(5);
+
+ if (createNewLexicalScope) {
+ this.scope.enter(SCOPE_OTHER);
+ }
+
+ this.parseBlockBody(node, allowDirectives, false, 8, afterBlockParse);
+
+ if (createNewLexicalScope) {
+ this.scope.exit();
+ }
+
+ return this.finishNode(node, "BlockStatement");
+ }
+
+ isValidDirective(stmt) {
+ return stmt.type === "ExpressionStatement" && stmt.expression.type === "StringLiteral" && !stmt.expression.extra.parenthesized;
+ }
+
+ parseBlockBody(node, allowDirectives, topLevel, end, afterBlockParse) {
+ const body = node.body = [];
+ const directives = node.directives = [];
+ this.parseBlockOrModuleBlockBody(body, allowDirectives ? directives : undefined, topLevel, end, afterBlockParse);
+ }
+
+ parseBlockOrModuleBlockBody(body, directives, topLevel, end, afterBlockParse) {
+ const oldStrict = this.state.strict;
+ let hasStrictModeDirective = false;
+ let parsedNonDirective = false;
+
+ while (!this.match(end)) {
+ const stmt = this.parseStatement(null, topLevel);
+
+ if (directives && !parsedNonDirective) {
+ if (this.isValidDirective(stmt)) {
+ const directive = this.stmtToDirective(stmt);
+ directives.push(directive);
+
+ if (!hasStrictModeDirective && directive.value.value === "use strict") {
+ hasStrictModeDirective = true;
+ this.setStrict(true);
+ }
+
+ continue;
+ }
+
+ parsedNonDirective = true;
+ this.state.strictErrors.clear();
+ }
+
+ body.push(stmt);
+ }
+
+ if (afterBlockParse) {
+ afterBlockParse.call(this, hasStrictModeDirective);
+ }
+
+ if (!oldStrict) {
+ this.setStrict(false);
+ }
+
+ this.next();
+ }
+
+ parseFor(node, init) {
+ node.init = init;
+ this.semicolon(false);
+ node.test = this.match(13) ? null : this.parseExpression();
+ this.semicolon(false);
+ node.update = this.match(11) ? null : this.parseExpression();
+ this.expect(11);
+ node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement("for"));
+ this.scope.exit();
+ this.state.labels.pop();
+ return this.finishNode(node, "ForStatement");
+ }
+
+ parseForIn(node, init, awaitAt) {
+ const isForIn = this.match(58);
+ this.next();
+
+ if (isForIn) {
+ if (awaitAt !== null) this.unexpected(awaitAt);
+ } else {
+ node.await = awaitAt !== null;
+ }
+
+ if (init.type === "VariableDeclaration" && init.declarations[0].init != null && (!isForIn || this.state.strict || init.kind !== "var" || init.declarations[0].id.type !== "Identifier")) {
+ this.raise(ErrorMessages.ForInOfLoopInitializer, {
+ node: init
+ }, isForIn ? "for-in" : "for-of");
+ }
+
+ if (init.type === "AssignmentPattern") {
+ this.raise(ErrorMessages.InvalidLhs, {
+ node: init
+ }, "for-loop");
+ }
+
+ node.left = init;
+ node.right = isForIn ? this.parseExpression() : this.parseMaybeAssignAllowIn();
+ this.expect(11);
+ node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement("for"));
+ this.scope.exit();
+ this.state.labels.pop();
+ return this.finishNode(node, isForIn ? "ForInStatement" : "ForOfStatement");
+ }
+
+ parseVar(node, isFor, kind) {
+ const declarations = node.declarations = [];
+ const isTypescript = this.hasPlugin("typescript");
+ node.kind = kind;
+
+ for (;;) {
+ const decl = this.startNode();
+ this.parseVarId(decl, kind);
+
+ if (this.eat(29)) {
+ decl.init = isFor ? this.parseMaybeAssignDisallowIn() : this.parseMaybeAssignAllowIn();
+ } else {
+ if (kind === "const" && !(this.match(58) || this.isContextual(101))) {
+ if (!isTypescript) {
+ this.raise(ErrorMessages.DeclarationMissingInitializer, {
+ at: this.state.lastTokEndLoc
+ }, "Const declarations");
+ }
+ } else if (decl.id.type !== "Identifier" && !(isFor && (this.match(58) || this.isContextual(101)))) {
+ this.raise(ErrorMessages.DeclarationMissingInitializer, {
+ at: this.state.lastTokEndLoc
+ }, "Complex binding patterns");
+ }
+
+ decl.init = null;
+ }
+
+ declarations.push(this.finishNode(decl, "VariableDeclarator"));
+ if (!this.eat(12)) break;
+ }
+
+ return node;
+ }
+
+ parseVarId(decl, kind) {
+ decl.id = this.parseBindingAtom();
+ this.checkLVal(decl.id, "variable declaration", kind === "var" ? BIND_VAR : BIND_LEXICAL, undefined, kind !== "var");
+ }
+
+ parseFunction(node, statement = FUNC_NO_FLAGS, isAsync = false) {
+ const isStatement = statement & FUNC_STATEMENT;
+ const isHangingStatement = statement & FUNC_HANGING_STATEMENT;
+ const requireId = !!isStatement && !(statement & FUNC_NULLABLE_ID);
+ this.initFunction(node, isAsync);
+
+ if (this.match(55) && isHangingStatement) {
+ this.raise(ErrorMessages.GeneratorInSingleStatementContext, {
+ at: this.state.startLoc
+ });
+ }
+
+ node.generator = this.eat(55);
+
+ if (isStatement) {
+ node.id = this.parseFunctionId(requireId);
+ }
+
+ const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;
+ this.state.maybeInArrowParameters = false;
+ this.scope.enter(SCOPE_FUNCTION);
+ this.prodParam.enter(functionFlags(isAsync, node.generator));
+
+ if (!isStatement) {
+ node.id = this.parseFunctionId();
+ }
+
+ this.parseFunctionParams(node, false);
+ this.withSmartMixTopicForbiddingContext(() => {
+ this.parseFunctionBodyAndFinish(node, isStatement ? "FunctionDeclaration" : "FunctionExpression");
+ });
+ this.prodParam.exit();
+ this.scope.exit();
+
+ if (isStatement && !isHangingStatement) {
+ this.registerFunctionStatementId(node);
+ }
+
+ this.state.maybeInArrowParameters = oldMaybeInArrowParameters;
+ return node;
+ }
+
+ parseFunctionId(requireId) {
+ return requireId || tokenIsIdentifier(this.state.type) ? this.parseIdentifier() : null;
+ }
+
+ parseFunctionParams(node, allowModifiers) {
+ this.expect(10);
+ this.expressionScope.enter(newParameterDeclarationScope());
+ node.params = this.parseBindingList(11, 41, false, allowModifiers);
+ this.expressionScope.exit();
+ }
+
+ registerFunctionStatementId(node) {
+ if (!node.id) return;
+ this.scope.declareName(node.id.name, this.state.strict || node.generator || node.async ? this.scope.treatFunctionsAsVar ? BIND_VAR : BIND_LEXICAL : BIND_FUNCTION, node.id.loc.start);
+ }
+
+ parseClass(node, isStatement, optionalId) {
+ this.next();
+ this.takeDecorators(node);
+ const oldStrict = this.state.strict;
+ this.state.strict = true;
+ this.parseClassId(node, isStatement, optionalId);
+ this.parseClassSuper(node);
+ node.body = this.parseClassBody(!!node.superClass, oldStrict);
+ return this.finishNode(node, isStatement ? "ClassDeclaration" : "ClassExpression");
+ }
+
+ isClassProperty() {
+ return this.match(29) || this.match(13) || this.match(8);
+ }
+
+ isClassMethod() {
+ return this.match(10);
+ }
+
+ isNonstaticConstructor(method) {
+ return !method.computed && !method.static && (method.key.name === "constructor" || method.key.value === "constructor");
+ }
+
+ parseClassBody(hadSuperClass, oldStrict) {
+ this.classScope.enter();
+ const state = {
+ hadConstructor: false,
+ hadSuperClass
+ };
+ let decorators = [];
+ const classBody = this.startNode();
+ classBody.body = [];
+ this.expect(5);
+ this.withSmartMixTopicForbiddingContext(() => {
+ while (!this.match(8)) {
+ if (this.eat(13)) {
+ if (decorators.length > 0) {
+ throw this.raise(ErrorMessages.DecoratorSemicolon, {
+ at: this.state.lastTokEndLoc
+ });
+ }
+
+ continue;
+ }
+
+ if (this.match(26)) {
+ decorators.push(this.parseDecorator());
+ continue;
+ }
+
+ const member = this.startNode();
+
+ if (decorators.length) {
+ member.decorators = decorators;
+ this.resetStartLocationFromNode(member, decorators[0]);
+ decorators = [];
+ }
+
+ this.parseClassMember(classBody, member, state);
+
+ if (member.kind === "constructor" && member.decorators && member.decorators.length > 0) {
+ this.raise(ErrorMessages.DecoratorConstructor, {
+ node: member
+ });
+ }
+ }
+ });
+ this.state.strict = oldStrict;
+ this.next();
+
+ if (decorators.length) {
+ throw this.raise(ErrorMessages.TrailingDecorator, {
+ at: this.state.startLoc
+ });
+ }
+
+ this.classScope.exit();
+ return this.finishNode(classBody, "ClassBody");
+ }
+
+ parseClassMemberFromModifier(classBody, member) {
+ const key = this.parseIdentifier(true);
+
+ if (this.isClassMethod()) {
+ const method = member;
+ method.kind = "method";
+ method.computed = false;
+ method.key = key;
+ method.static = false;
+ this.pushClassMethod(classBody, method, false, false, false, false);
+ return true;
+ } else if (this.isClassProperty()) {
+ const prop = member;
+ prop.computed = false;
+ prop.key = key;
+ prop.static = false;
+ classBody.body.push(this.parseClassProperty(prop));
+ return true;
+ }
+
+ this.resetPreviousNodeTrailingComments(key);
+ return false;
+ }
+
+ parseClassMember(classBody, member, state) {
+ const isStatic = this.isContextual(104);
+
+ if (isStatic) {
+ if (this.parseClassMemberFromModifier(classBody, member)) {
+ return;
+ }
+
+ if (this.eat(5)) {
+ this.parseClassStaticBlock(classBody, member);
+ return;
+ }
+ }
+
+ this.parseClassMemberWithIsStatic(classBody, member, state, isStatic);
+ }
+
+ parseClassMemberWithIsStatic(classBody, member, state, isStatic) {
+ const publicMethod = member;
+ const privateMethod = member;
+ const publicProp = member;
+ const privateProp = member;
+ const accessorProp = member;
+ const method = publicMethod;
+ const publicMember = publicMethod;
+ member.static = isStatic;
+ this.parsePropertyNamePrefixOperator(member);
+
+ if (this.eat(55)) {
+ method.kind = "method";
+ const isPrivateName = this.match(134);
+ this.parseClassElementName(method);
+
+ if (isPrivateName) {
+ this.pushClassPrivateMethod(classBody, privateMethod, true, false);
+ return;
+ }
+
+ if (this.isNonstaticConstructor(publicMethod)) {
+ this.raise(ErrorMessages.ConstructorIsGenerator, {
+ node: publicMethod.key
+ });
+ }
+
+ this.pushClassMethod(classBody, publicMethod, true, false, false, false);
+ return;
+ }
+
+ const isContextual = tokenIsIdentifier(this.state.type) && !this.state.containsEsc;
+ const isPrivate = this.match(134);
+ const key = this.parseClassElementName(member);
+ const maybeQuestionTokenStartLoc = this.state.startLoc;
+ this.parsePostMemberNameModifiers(publicMember);
+
+ if (this.isClassMethod()) {
+ method.kind = "method";
+
+ if (isPrivate) {
+ this.pushClassPrivateMethod(classBody, privateMethod, false, false);
+ return;
+ }
+
+ const isConstructor = this.isNonstaticConstructor(publicMethod);
+ let allowsDirectSuper = false;
+
+ if (isConstructor) {
+ publicMethod.kind = "constructor";
+
+ if (state.hadConstructor && !this.hasPlugin("typescript")) {
+ this.raise(ErrorMessages.DuplicateConstructor, {
+ node: key
+ });
+ }
+
+ if (isConstructor && this.hasPlugin("typescript") && member.override) {
+ this.raise(ErrorMessages.OverrideOnConstructor, {
+ node: key
+ });
+ }
+
+ state.hadConstructor = true;
+ allowsDirectSuper = state.hadSuperClass;
+ }
+
+ this.pushClassMethod(classBody, publicMethod, false, false, isConstructor, allowsDirectSuper);
+ } else if (this.isClassProperty()) {
+ if (isPrivate) {
+ this.pushClassPrivateProperty(classBody, privateProp);
+ } else {
+ this.pushClassProperty(classBody, publicProp);
+ }
+ } else if (isContextual && key.name === "async" && !this.isLineTerminator()) {
+ this.resetPreviousNodeTrailingComments(key);
+ const isGenerator = this.eat(55);
+
+ if (publicMember.optional) {
+ this.unexpected(maybeQuestionTokenStartLoc);
+ }
+
+ method.kind = "method";
+ const isPrivate = this.match(134);
+ this.parseClassElementName(method);
+ this.parsePostMemberNameModifiers(publicMember);
+
+ if (isPrivate) {
+ this.pushClassPrivateMethod(classBody, privateMethod, isGenerator, true);
+ } else {
+ if (this.isNonstaticConstructor(publicMethod)) {
+ this.raise(ErrorMessages.ConstructorIsAsync, {
+ node: publicMethod.key
+ });
+ }
+
+ this.pushClassMethod(classBody, publicMethod, isGenerator, true, false, false);
+ }
+ } else if (isContextual && (key.name === "get" || key.name === "set") && !(this.match(55) && this.isLineTerminator())) {
+ this.resetPreviousNodeTrailingComments(key);
+ method.kind = key.name;
+ const isPrivate = this.match(134);
+ this.parseClassElementName(publicMethod);
+
+ if (isPrivate) {
+ this.pushClassPrivateMethod(classBody, privateMethod, false, false);
+ } else {
+ if (this.isNonstaticConstructor(publicMethod)) {
+ this.raise(ErrorMessages.ConstructorIsAccessor, {
+ node: publicMethod.key
+ });
+ }
+
+ this.pushClassMethod(classBody, publicMethod, false, false, false, false);
+ }
+
+ this.checkGetterSetterParams(publicMethod);
+ } else if (isContextual && key.name === "accessor" && !this.isLineTerminator()) {
+ this.expectPlugin("decoratorAutoAccessors");
+ this.resetPreviousNodeTrailingComments(key);
+ const isPrivate = this.match(134);
+ this.parseClassElementName(publicProp);
+ this.pushClassAccessorProperty(classBody, accessorProp, isPrivate);
+ } else if (this.isLineTerminator()) {
+ if (isPrivate) {
+ this.pushClassPrivateProperty(classBody, privateProp);
+ } else {
+ this.pushClassProperty(classBody, publicProp);
+ }
+ } else {
+ this.unexpected();
+ }
+ }
+
+ parseClassElementName(member) {
+ const {
+ type,
+ value
+ } = this.state;
+
+ if ((type === 128 || type === 129) && member.static && value === "prototype") {
+ this.raise(ErrorMessages.StaticPrototype, {
+ at: this.state.startLoc
+ });
+ }
+
+ if (type === 134) {
+ if (value === "constructor") {
+ this.raise(ErrorMessages.ConstructorClassPrivateField, {
+ at: this.state.startLoc
+ });
+ }
+
+ const key = this.parsePrivateName();
+ member.key = key;
+ return key;
+ }
+
+ return this.parsePropertyName(member);
+ }
+
+ parseClassStaticBlock(classBody, member) {
+ var _member$decorators;
+
+ this.scope.enter(SCOPE_CLASS | SCOPE_STATIC_BLOCK | SCOPE_SUPER);
+ const oldLabels = this.state.labels;
+ this.state.labels = [];
+ this.prodParam.enter(PARAM);
+ const body = member.body = [];
+ this.parseBlockOrModuleBlockBody(body, undefined, false, 8);
+ this.prodParam.exit();
+ this.scope.exit();
+ this.state.labels = oldLabels;
+ classBody.body.push(this.finishNode(member, "StaticBlock"));
+
+ if ((_member$decorators = member.decorators) != null && _member$decorators.length) {
+ this.raise(ErrorMessages.DecoratorStaticBlock, {
+ node: member
+ });
+ }
+ }
+
+ pushClassProperty(classBody, prop) {
+ if (!prop.computed && (prop.key.name === "constructor" || prop.key.value === "constructor")) {
+ this.raise(ErrorMessages.ConstructorClassField, {
+ node: prop.key
+ });
+ }
+
+ classBody.body.push(this.parseClassProperty(prop));
+ }
+
+ pushClassPrivateProperty(classBody, prop) {
+ const node = this.parseClassPrivateProperty(prop);
+ classBody.body.push(node);
+ this.classScope.declarePrivateName(this.getPrivateNameSV(node.key), CLASS_ELEMENT_OTHER, node.key.loc.start);
+ }
+
+ pushClassAccessorProperty(classBody, prop, isPrivate) {
+ if (!isPrivate && !prop.computed) {
+ const key = prop.key;
+
+ if (key.name === "constructor" || key.value === "constructor") {
+ this.raise(ErrorMessages.ConstructorClassField, {
+ node: key
+ });
+ }
+ }
+
+ const node = this.parseClassAccessorProperty(prop);
+ classBody.body.push(node);
+
+ if (isPrivate) {
+ this.classScope.declarePrivateName(this.getPrivateNameSV(node.key), CLASS_ELEMENT_OTHER, node.key.loc.start);
+ }
+ }
+
+ pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) {
+ classBody.body.push(this.parseMethod(method, isGenerator, isAsync, isConstructor, allowsDirectSuper, "ClassMethod", true));
+ }
+
+ pushClassPrivateMethod(classBody, method, isGenerator, isAsync) {
+ const node = this.parseMethod(method, isGenerator, isAsync, false, false, "ClassPrivateMethod", true);
+ classBody.body.push(node);
+ const kind = node.kind === "get" ? node.static ? CLASS_ELEMENT_STATIC_GETTER : CLASS_ELEMENT_INSTANCE_GETTER : node.kind === "set" ? node.static ? CLASS_ELEMENT_STATIC_SETTER : CLASS_ELEMENT_INSTANCE_SETTER : CLASS_ELEMENT_OTHER;
+ this.declareClassPrivateMethodInScope(node, kind);
+ }
+
+ declareClassPrivateMethodInScope(node, kind) {
+ this.classScope.declarePrivateName(this.getPrivateNameSV(node.key), kind, node.key.loc.start);
+ }
+
+ parsePostMemberNameModifiers(methodOrProp) {}
+
+ parseClassPrivateProperty(node) {
+ this.parseInitializer(node);
+ this.semicolon();
+ return this.finishNode(node, "ClassPrivateProperty");
+ }
+
+ parseClassProperty(node) {
+ this.parseInitializer(node);
+ this.semicolon();
+ return this.finishNode(node, "ClassProperty");
+ }
+
+ parseClassAccessorProperty(node) {
+ this.parseInitializer(node);
+ this.semicolon();
+ return this.finishNode(node, "ClassAccessorProperty");
+ }
+
+ parseInitializer(node) {
+ this.scope.enter(SCOPE_CLASS | SCOPE_SUPER);
+ this.expressionScope.enter(newExpressionScope());
+ this.prodParam.enter(PARAM);
+ node.value = this.eat(29) ? this.parseMaybeAssignAllowIn() : null;
+ this.expressionScope.exit();
+ this.prodParam.exit();
+ this.scope.exit();
+ }
+
+ parseClassId(node, isStatement, optionalId, bindingType = BIND_CLASS) {
+ if (tokenIsIdentifier(this.state.type)) {
+ node.id = this.parseIdentifier();
+
+ if (isStatement) {
+ this.checkLVal(node.id, "class name", bindingType);
+ }
+ } else {
+ if (optionalId || !isStatement) {
+ node.id = null;
+ } else {
+ throw this.raise(ErrorMessages.MissingClassName, {
+ at: this.state.startLoc
+ });
+ }
+ }
+ }
+
+ parseClassSuper(node) {
+ node.superClass = this.eat(81) ? this.parseExprSubscripts() : null;
+ }
+
+ parseExport(node) {
+ const hasDefault = this.maybeParseExportDefaultSpecifier(node);
+ const parseAfterDefault = !hasDefault || this.eat(12);
+ const hasStar = parseAfterDefault && this.eatExportStar(node);
+ const hasNamespace = hasStar && this.maybeParseExportNamespaceSpecifier(node);
+ const parseAfterNamespace = parseAfterDefault && (!hasNamespace || this.eat(12));
+ const isFromRequired = hasDefault || hasStar;
+
+ if (hasStar && !hasNamespace) {
+ if (hasDefault) this.unexpected();
+ this.parseExportFrom(node, true);
+ return this.finishNode(node, "ExportAllDeclaration");
+ }
+
+ const hasSpecifiers = this.maybeParseExportNamedSpecifiers(node);
+
+ if (hasDefault && parseAfterDefault && !hasStar && !hasSpecifiers || hasNamespace && parseAfterNamespace && !hasSpecifiers) {
+ throw this.unexpected(null, 5);
+ }
+
+ let hasDeclaration;
+
+ if (isFromRequired || hasSpecifiers) {
+ hasDeclaration = false;
+ this.parseExportFrom(node, isFromRequired);
+ } else {
+ hasDeclaration = this.maybeParseExportDeclaration(node);
+ }
+
+ if (isFromRequired || hasSpecifiers || hasDeclaration) {
+ this.checkExport(node, true, false, !!node.source);
+ return this.finishNode(node, "ExportNamedDeclaration");
+ }
+
+ if (this.eat(65)) {
+ node.declaration = this.parseExportDefaultExpression();
+ this.checkExport(node, true, true);
+ return this.finishNode(node, "ExportDefaultDeclaration");
+ }
+
+ throw this.unexpected(null, 5);
+ }
+
+ eatExportStar(node) {
+ return this.eat(55);
+ }
+
+ maybeParseExportDefaultSpecifier(node) {
+ if (this.isExportDefaultSpecifier()) {
+ this.expectPlugin("exportDefaultFrom");
+ const specifier = this.startNode();
+ specifier.exported = this.parseIdentifier(true);
+ node.specifiers = [this.finishNode(specifier, "ExportDefaultSpecifier")];
+ return true;
+ }
+
+ return false;
+ }
+
+ maybeParseExportNamespaceSpecifier(node) {
+ if (this.isContextual(93)) {
+ if (!node.specifiers) node.specifiers = [];
+ const specifier = this.startNodeAt(this.state.lastTokStart, this.state.lastTokStartLoc);
+ this.next();
+ specifier.exported = this.parseModuleExportName();
+ node.specifiers.push(this.finishNode(specifier, "ExportNamespaceSpecifier"));
+ return true;
+ }
+
+ return false;
+ }
+
+ maybeParseExportNamedSpecifiers(node) {
+ if (this.match(5)) {
+ if (!node.specifiers) node.specifiers = [];
+ const isTypeExport = node.exportKind === "type";
+ node.specifiers.push(...this.parseExportSpecifiers(isTypeExport));
+ node.source = null;
+ node.declaration = null;
+
+ if (this.hasPlugin("importAssertions")) {
+ node.assertions = [];
+ }
+
+ return true;
+ }
+
+ return false;
+ }
+
+ maybeParseExportDeclaration(node) {
+ if (this.shouldParseExportDeclaration()) {
+ node.specifiers = [];
+ node.source = null;
+
+ if (this.hasPlugin("importAssertions")) {
+ node.assertions = [];
+ }
+
+ node.declaration = this.parseExportDeclaration(node);
+ return true;
+ }
+
+ return false;
+ }
+
+ isAsyncFunction() {
+ if (!this.isContextual(95)) return false;
+ const next = this.nextTokenStart();
+ return !lineBreak.test(this.input.slice(this.state.pos, next)) && this.isUnparsedContextual(next, "function");
+ }
+
+ parseExportDefaultExpression() {
+ const expr = this.startNode();
+ const isAsync = this.isAsyncFunction();
+
+ if (this.match(68) || isAsync) {
+ this.next();
+
+ if (isAsync) {
+ this.next();
+ }
+
+ return this.parseFunction(expr, FUNC_STATEMENT | FUNC_NULLABLE_ID, isAsync);
+ }
+
+ if (this.match(80)) {
+ return this.parseClass(expr, true, true);
+ }
+
+ if (this.match(26)) {
+ if (this.hasPlugin("decorators") && this.getPluginOption("decorators", "decoratorsBeforeExport")) {
+ this.raise(ErrorMessages.DecoratorBeforeExport, {
+ at: this.state.startLoc
+ });
+ }
+
+ this.parseDecorators(false);
+ return this.parseClass(expr, true, true);
+ }
+
+ if (this.match(75) || this.match(74) || this.isLet()) {
+ throw this.raise(ErrorMessages.UnsupportedDefaultExport, {
+ at: this.state.startLoc
+ });
+ }
+
+ const res = this.parseMaybeAssignAllowIn();
+ this.semicolon();
+ return res;
+ }
+
+ parseExportDeclaration(node) {
+ return this.parseStatement(null);
+ }
+
+ isExportDefaultSpecifier() {
+ const {
+ type
+ } = this.state;
+
+ if (tokenIsIdentifier(type)) {
+ if (type === 95 && !this.state.containsEsc || type === 99) {
+ return false;
+ }
+
+ if ((type === 126 || type === 125) && !this.state.containsEsc) {
+ const {
+ type: nextType
+ } = this.lookahead();
+
+ if (tokenIsIdentifier(nextType) && nextType !== 97 || nextType === 5) {
+ this.expectOnePlugin(["flow", "typescript"]);
+ return false;
+ }
+ }
+ } else if (!this.match(65)) {
+ return false;
+ }
+
+ const next = this.nextTokenStart();
+ const hasFrom = this.isUnparsedContextual(next, "from");
+
+ if (this.input.charCodeAt(next) === 44 || tokenIsIdentifier(this.state.type) && hasFrom) {
+ return true;
+ }
+
+ if (this.match(65) && hasFrom) {
+ const nextAfterFrom = this.input.charCodeAt(this.nextTokenStartSince(next + 4));
+ return nextAfterFrom === 34 || nextAfterFrom === 39;
+ }
+
+ return false;
+ }
+
+ parseExportFrom(node, expect) {
+ if (this.eatContextual(97)) {
+ node.source = this.parseImportSource();
+ this.checkExport(node);
+ const assertions = this.maybeParseImportAssertions();
+
+ if (assertions) {
+ node.assertions = assertions;
+ }
+ } else if (expect) {
+ this.unexpected();
+ }
+
+ this.semicolon();
+ }
+
+ shouldParseExportDeclaration() {
+ const {
+ type
+ } = this.state;
+
+ if (type === 26) {
+ this.expectOnePlugin(["decorators", "decorators-legacy"]);
+
+ if (this.hasPlugin("decorators")) {
+ if (this.getPluginOption("decorators", "decoratorsBeforeExport")) {
+ throw this.raise(ErrorMessages.DecoratorBeforeExport, {
+ at: this.state.startLoc
+ });
+ }
+
+ return true;
+ }
+ }
+
+ return type === 74 || type === 75 || type === 68 || type === 80 || this.isLet() || this.isAsyncFunction();
+ }
+
+ checkExport(node, checkNames, isDefault, isFrom) {
+ if (checkNames) {
+ if (isDefault) {
+ this.checkDuplicateExports(node, "default");
+
+ if (this.hasPlugin("exportDefaultFrom")) {
+ var _declaration$extra;
+
+ const declaration = node.declaration;
+
+ if (declaration.type === "Identifier" && declaration.name === "from" && declaration.end - declaration.start === 4 && !((_declaration$extra = declaration.extra) != null && _declaration$extra.parenthesized)) {
+ this.raise(ErrorMessages.ExportDefaultFromAsIdentifier, {
+ node: declaration
+ });
+ }
+ }
+ } else if (node.specifiers && node.specifiers.length) {
+ for (const specifier of node.specifiers) {
+ const {
+ exported
+ } = specifier;
+ const exportedName = exported.type === "Identifier" ? exported.name : exported.value;
+ this.checkDuplicateExports(specifier, exportedName);
+
+ if (!isFrom && specifier.local) {
+ const {
+ local
+ } = specifier;
+
+ if (local.type !== "Identifier") {
+ this.raise(ErrorMessages.ExportBindingIsString, {
+ node: specifier
+ }, local.value, exportedName);
+ } else {
+ this.checkReservedWord(local.name, local.loc.start, true, false);
+ this.scope.checkLocalExport(local);
+ }
+ }
+ }
+ } else if (node.declaration) {
+ if (node.declaration.type === "FunctionDeclaration" || node.declaration.type === "ClassDeclaration") {
+ const id = node.declaration.id;
+ if (!id) throw new Error("Assertion failure");
+ this.checkDuplicateExports(node, id.name);
+ } else if (node.declaration.type === "VariableDeclaration") {
+ for (const declaration of node.declaration.declarations) {
+ this.checkDeclaration(declaration.id);
+ }
+ }
+ }
+ }
+
+ const currentContextDecorators = this.state.decoratorStack[this.state.decoratorStack.length - 1];
+
+ if (currentContextDecorators.length) {
+ throw this.raise(ErrorMessages.UnsupportedDecoratorExport, {
+ node
+ });
+ }
+ }
+
+ checkDeclaration(node) {
+ if (node.type === "Identifier") {
+ this.checkDuplicateExports(node, node.name);
+ } else if (node.type === "ObjectPattern") {
+ for (const prop of node.properties) {
+ this.checkDeclaration(prop);
+ }
+ } else if (node.type === "ArrayPattern") {
+ for (const elem of node.elements) {
+ if (elem) {
+ this.checkDeclaration(elem);
+ }
+ }
+ } else if (node.type === "ObjectProperty") {
+ this.checkDeclaration(node.value);
+ } else if (node.type === "RestElement") {
+ this.checkDeclaration(node.argument);
+ } else if (node.type === "AssignmentPattern") {
+ this.checkDeclaration(node.left);
+ }
+ }
+
+ checkDuplicateExports(node, name) {
+ if (this.exportedIdentifiers.has(name)) {
+ this.raise(name === "default" ? ErrorMessages.DuplicateDefaultExport : ErrorMessages.DuplicateExport, {
+ node
+ }, name);
+ }
+
+ this.exportedIdentifiers.add(name);
+ }
+
+ parseExportSpecifiers(isInTypeExport) {
+ const nodes = [];
+ let first = true;
+ this.expect(5);
+
+ while (!this.eat(8)) {
+ if (first) {
+ first = false;
+ } else {
+ this.expect(12);
+ if (this.eat(8)) break;
+ }
+
+ const isMaybeTypeOnly = this.isContextual(126);
+ const isString = this.match(129);
+ const node = this.startNode();
+ node.local = this.parseModuleExportName();
+ nodes.push(this.parseExportSpecifier(node, isString, isInTypeExport, isMaybeTypeOnly));
+ }
+
+ return nodes;
+ }
+
+ parseExportSpecifier(node, isString, isInTypeExport, isMaybeTypeOnly) {
+ if (this.eatContextual(93)) {
+ node.exported = this.parseModuleExportName();
+ } else if (isString) {
+ node.exported = cloneStringLiteral(node.local);
+ } else if (!node.exported) {
+ node.exported = cloneIdentifier(node.local);
+ }
+
+ return this.finishNode(node, "ExportSpecifier");
+ }
+
+ parseModuleExportName() {
+ if (this.match(129)) {
+ const result = this.parseStringLiteral(this.state.value);
+ const surrogate = result.value.match(loneSurrogate);
+
+ if (surrogate) {
+ this.raise(ErrorMessages.ModuleExportNameHasLoneSurrogate, {
+ node: result
+ }, surrogate[0].charCodeAt(0).toString(16));
+ }
+
+ return result;
+ }
+
+ return this.parseIdentifier(true);
+ }
+
+ parseImport(node) {
+ node.specifiers = [];
+
+ if (!this.match(129)) {
+ const hasDefault = this.maybeParseDefaultImportSpecifier(node);
+ const parseNext = !hasDefault || this.eat(12);
+ const hasStar = parseNext && this.maybeParseStarImportSpecifier(node);
+ if (parseNext && !hasStar) this.parseNamedImportSpecifiers(node);
+ this.expectContextual(97);
+ }
+
+ node.source = this.parseImportSource();
+ const assertions = this.maybeParseImportAssertions();
+
+ if (assertions) {
+ node.assertions = assertions;
+ } else {
+ const attributes = this.maybeParseModuleAttributes();
+
+ if (attributes) {
+ node.attributes = attributes;
+ }
+ }
+
+ this.semicolon();
+ return this.finishNode(node, "ImportDeclaration");
+ }
+
+ parseImportSource() {
+ if (!this.match(129)) this.unexpected();
+ return this.parseExprAtom();
+ }
+
+ shouldParseDefaultImport(node) {
+ return tokenIsIdentifier(this.state.type);
+ }
+
+ parseImportSpecifierLocal(node, specifier, type, contextDescription) {
+ specifier.local = this.parseIdentifier();
+ this.checkLVal(specifier.local, contextDescription, BIND_LEXICAL);
+ node.specifiers.push(this.finishNode(specifier, type));
+ }
+
+ parseAssertEntries() {
+ const attrs = [];
+ const attrNames = new Set();
+
+ do {
+ if (this.match(8)) {
+ break;
+ }
+
+ const node = this.startNode();
+ const keyName = this.state.value;
+
+ if (attrNames.has(keyName)) {
+ this.raise(ErrorMessages.ModuleAttributesWithDuplicateKeys, {
+ at: this.state.startLoc
+ }, keyName);
+ }
+
+ attrNames.add(keyName);
+
+ if (this.match(129)) {
+ node.key = this.parseStringLiteral(keyName);
+ } else {
+ node.key = this.parseIdentifier(true);
+ }
+
+ this.expect(14);
+
+ if (!this.match(129)) {
+ throw this.raise(ErrorMessages.ModuleAttributeInvalidValue, {
+ at: this.state.startLoc
+ });
+ }
+
+ node.value = this.parseStringLiteral(this.state.value);
+ this.finishNode(node, "ImportAttribute");
+ attrs.push(node);
+ } while (this.eat(12));
+
+ return attrs;
+ }
+
+ maybeParseModuleAttributes() {
+ if (this.match(76) && !this.hasPrecedingLineBreak()) {
+ this.expectPlugin("moduleAttributes");
+ this.next();
+ } else {
+ if (this.hasPlugin("moduleAttributes")) return [];
+ return null;
+ }
+
+ const attrs = [];
+ const attributes = new Set();
+
+ do {
+ const node = this.startNode();
+ node.key = this.parseIdentifier(true);
+
+ if (node.key.name !== "type") {
+ this.raise(ErrorMessages.ModuleAttributeDifferentFromType, {
+ node: node.key
+ }, node.key.name);
+ }
+
+ if (attributes.has(node.key.name)) {
+ this.raise(ErrorMessages.ModuleAttributesWithDuplicateKeys, {
+ node: node.key
+ }, node.key.name);
+ }
+
+ attributes.add(node.key.name);
+ this.expect(14);
+
+ if (!this.match(129)) {
+ throw this.raise(ErrorMessages.ModuleAttributeInvalidValue, {
+ at: this.state.startLoc
+ });
+ }
+
+ node.value = this.parseStringLiteral(this.state.value);
+ this.finishNode(node, "ImportAttribute");
+ attrs.push(node);
+ } while (this.eat(12));
+
+ return attrs;
+ }
+
+ maybeParseImportAssertions() {
+ if (this.isContextual(94) && !this.hasPrecedingLineBreak()) {
+ this.expectPlugin("importAssertions");
+ this.next();
+ } else {
+ if (this.hasPlugin("importAssertions")) return [];
+ return null;
+ }
+
+ this.eat(5);
+ const attrs = this.parseAssertEntries();
+ this.eat(8);
+ return attrs;
+ }
+
+ maybeParseDefaultImportSpecifier(node) {
+ if (this.shouldParseDefaultImport(node)) {
+ this.parseImportSpecifierLocal(node, this.startNode(), "ImportDefaultSpecifier", "default import specifier");
+ return true;
+ }
+
+ return false;
+ }
+
+ maybeParseStarImportSpecifier(node) {
+ if (this.match(55)) {
+ const specifier = this.startNode();
+ this.next();
+ this.expectContextual(93);
+ this.parseImportSpecifierLocal(node, specifier, "ImportNamespaceSpecifier", "import namespace specifier");
+ return true;
+ }
+
+ return false;
+ }
+
+ parseNamedImportSpecifiers(node) {
+ let first = true;
+ this.expect(5);
+
+ while (!this.eat(8)) {
+ if (first) {
+ first = false;
+ } else {
+ if (this.eat(14)) {
+ throw this.raise(ErrorMessages.DestructureNamedImport, {
+ at: this.state.startLoc
+ });
+ }
+
+ this.expect(12);
+ if (this.eat(8)) break;
+ }
+
+ const specifier = this.startNode();
+ const importedIsString = this.match(129);
+ const isMaybeTypeOnly = this.isContextual(126);
+ specifier.imported = this.parseModuleExportName();
+ const importSpecifier = this.parseImportSpecifier(specifier, importedIsString, node.importKind === "type" || node.importKind === "typeof", isMaybeTypeOnly);
+ node.specifiers.push(importSpecifier);
+ }
+ }
+
+ parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly) {
+ if (this.eatContextual(93)) {
+ specifier.local = this.parseIdentifier();
+ } else {
+ const {
+ imported
+ } = specifier;
+
+ if (importedIsString) {
+ throw this.raise(ErrorMessages.ImportBindingIsString, {
+ node: specifier
+ }, imported.value);
+ }
+
+ this.checkReservedWord(imported.name, specifier.loc.start, true, true);
+
+ if (!specifier.local) {
+ specifier.local = cloneIdentifier(imported);
+ }
+ }
+
+ this.checkLVal(specifier.local, "import specifier", BIND_LEXICAL);
+ return this.finishNode(specifier, "ImportSpecifier");
+ }
+
+ isThisParam(param) {
+ return param.type === "Identifier" && param.name === "this";
+ }
+
+}
+
+class Parser extends StatementParser {
+ constructor(options, input) {
+ options = getOptions(options);
+ super(options, input);
+ this.options = options;
+ this.initializeScopes();
+ this.plugins = pluginsMap(this.options.plugins);
+ this.filename = options.sourceFilename;
+ }
+
+ getScopeHandler() {
+ return ScopeHandler;
+ }
+
+ parse() {
+ this.enterInitialScopes();
+ const file = this.startNode();
+ const program = this.startNode();
+ this.nextToken();
+ file.errors = null;
+ this.parseTopLevel(file, program);
+ file.errors = this.state.errors;
+ return file;
+ }
+
+}
+
+function pluginsMap(plugins) {
+ const pluginMap = new Map();
+
+ for (const plugin of plugins) {
+ const [name, options] = Array.isArray(plugin) ? plugin : [plugin, {}];
+ if (!pluginMap.has(name)) pluginMap.set(name, options || {});
+ }
+
+ return pluginMap;
+}
+
+function parse(input, options) {
+ var _options;
+
+ if (((_options = options) == null ? void 0 : _options.sourceType) === "unambiguous") {
+ options = Object.assign({}, options);
+
+ try {
+ options.sourceType = "module";
+ const parser = getParser(options, input);
+ const ast = parser.parse();
+
+ if (parser.sawUnambiguousESM) {
+ return ast;
+ }
+
+ if (parser.ambiguousScriptDifferentAst) {
+ try {
+ options.sourceType = "script";
+ return getParser(options, input).parse();
+ } catch (_unused) {}
+ } else {
+ ast.program.sourceType = "script";
+ }
+
+ return ast;
+ } catch (moduleError) {
+ try {
+ options.sourceType = "script";
+ return getParser(options, input).parse();
+ } catch (_unused2) {}
+
+ throw moduleError;
+ }
+ } else {
+ return getParser(options, input).parse();
+ }
+}
+function parseExpression(input, options) {
+ const parser = getParser(options, input);
+
+ if (parser.options.strictMode) {
+ parser.state.strict = true;
+ }
+
+ return parser.getExpression();
+}
+
+function generateExportedTokenTypes(internalTokenTypes) {
+ const tokenTypes = {};
+
+ for (const typeName of Object.keys(internalTokenTypes)) {
+ tokenTypes[typeName] = getExportedToken(internalTokenTypes[typeName]);
+ }
+
+ return tokenTypes;
+}
+
+const tokTypes = generateExportedTokenTypes(tt);
+
+function getParser(options, input) {
+ let cls = Parser;
+
+ if (options != null && options.plugins) {
+ validatePlugins(options.plugins);
+ cls = getParserClass(options.plugins);
+ }
+
+ return new cls(options, input);
+}
+
+const parserClassCache = {};
+
+function getParserClass(pluginsFromOptions) {
+ const pluginList = mixinPluginNames.filter(name => hasPlugin(pluginsFromOptions, name));
+ const key = pluginList.join("/");
+ let cls = parserClassCache[key];
+
+ if (!cls) {
+ cls = Parser;
+
+ for (const plugin of pluginList) {
+ cls = mixinPlugins[plugin](cls);
+ }
+
+ parserClassCache[key] = cls;
+ }
+
+ return cls;
+}
+
+exports.parse = parse;
+exports.parseExpression = parseExpression;
+exports.tokTypes = tokTypes;
+//# sourceMappingURL=index.js.map
diff --git a/node_modules/@babel/parser/lib/index.js.map b/node_modules/@babel/parser/lib/index.js.map
new file mode 100644
index 000000000..4c35ccf50
--- /dev/null
+++ b/node_modules/@babel/parser/lib/index.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../src/parser/base.js","../src/parser/comments.js","../src/parser/error-codes.js","../src/parser/error-message.js","../src/parser/error.js","../src/plugins/estree.js","../src/tokenizer/context.js","../src/tokenizer/types.js","../src/util/location.js","../../babel-helper-validator-identifier/src/identifier.ts","../../babel-helper-validator-identifier/src/keyword.ts","../src/util/identifier.js","../src/util/scopeflags.js","../src/util/scope.js","../src/plugins/flow/scope.js","../src/util/whitespace.js","../src/tokenizer/state.js","../src/tokenizer/index.js","../src/util/class-scope.js","../src/util/expression-scope.js","../src/util/production-parameter.js","../src/parser/util.js","../src/parser/node.js","../src/plugins/flow/index.js","../src/plugins/jsx/xhtml.js","../src/plugins/jsx/index.js","../src/plugins/typescript/scope.js","../src/plugins/typescript/index.js","../src/plugins/placeholders.js","../src/plugins/v8intrinsic.js","../src/plugin-utils.js","../src/options.js","../src/parser/lval.js","../src/parser/expression.js","../src/parser/statement.js","../src/parser/index.js","../src/index.js"],"sourcesContent":["// @flow\n\nimport type { Options } from \"../options\";\nimport type State from \"../tokenizer/state\";\nimport type { PluginsMap } from \"./index\";\nimport type ScopeHandler from \"../util/scope\";\nimport type ExpressionScopeHandler from \"../util/expression-scope\";\nimport type ClassScopeHandler from \"../util/class-scope\";\nimport type ProductionParameterHandler from \"../util/production-parameter\";\n\nexport default class BaseParser {\n // Properties set by constructor in index.js\n declare options: Options;\n declare inModule: boolean;\n declare scope: ScopeHandler<*>;\n declare classScope: ClassScopeHandler;\n declare prodParam: ProductionParameterHandler;\n declare expressionScope: ExpressionScopeHandler;\n declare plugins: PluginsMap;\n declare filename: ?string;\n // Names of exports store. `default` is stored as a name for both\n // `export default foo;` and `export { foo as default };`.\n declare exportedIdentifiers: Set;\n sawUnambiguousESM: boolean = false;\n ambiguousScriptDifferentAst: boolean = false;\n\n // Initialized by Tokenizer\n declare state: State;\n // input and length are not in state as they are constant and we do\n // not want to ever copy them, which happens if state gets cloned\n declare input: string;\n declare length: number;\n\n // This method accepts either a string (plugin name) or an array pair\n // (plugin name and options object). If an options object is given,\n // then each value is non-recursively checked for identity with that\n // plugin’s actual option value.\n hasPlugin(pluginConfig: PluginConfig): boolean {\n if (typeof pluginConfig === \"string\") {\n return this.plugins.has(pluginConfig);\n } else {\n const [pluginName, pluginOptions] = pluginConfig;\n if (!this.hasPlugin(pluginName)) {\n return false;\n }\n const actualOptions = this.plugins.get(pluginName);\n for (const key of Object.keys(pluginOptions)) {\n if (actualOptions?.[key] !== pluginOptions[key]) {\n return false;\n }\n }\n return true;\n }\n }\n\n getPluginOption(plugin: string, name: string) {\n return this.plugins.get(plugin)?.[name];\n }\n}\n\nexport type PluginConfig = string | [string, { [string]: any }];\n","// @flow\n\n/*:: declare var invariant; */\n\nimport BaseParser from \"./base\";\nimport type { Comment, Node } from \"../types\";\nimport * as charCodes from \"charcodes\";\n\n/**\n * A whitespace token containing comments\n * @typedef CommentWhitespace\n * @type {object}\n * @property {number} start - the start of the whitespace token.\n * @property {number} end - the end of the whitespace token.\n * @property {Array} comments - the containing comments\n * @property {Node | null} leadingNode - the immediately preceding AST node of the whitespace token\n * @property {Node | null} trailingNode - the immediately following AST node of the whitespace token\n * @property {Node | null} containingNode - the innermost AST node containing the whitespace\n * with minimal size (|end - start|)\n */\nexport type CommentWhitespace = {\n start: number,\n end: number,\n comments: Array,\n leadingNode: Node | null,\n trailingNode: Node | null,\n containingNode: Node | null,\n};\n\n/**\n * Merge comments with node's trailingComments or assign comments to be\n * trailingComments. New comments will be placed before old comments\n * because the commentStack is enumerated reversely.\n *\n * @param {Node} node\n * @param {Array} comments\n */\nfunction setTrailingComments(node: Node, comments: Array) {\n if (node.trailingComments === undefined) {\n node.trailingComments = comments;\n } else {\n node.trailingComments.unshift(...comments);\n }\n}\n\n/**\n * Merge comments with node's leadingComments or assign comments to be\n * leadingComments. New comments will be placed before old comments\n * because the commentStack is enumerated reversely.\n *\n * @param {Node} node\n * @param {Array} comments\n */\nfunction setLeadingComments(node: Node, comments: Array) {\n if (node.leadingComments === undefined) {\n node.leadingComments = comments;\n } else {\n node.leadingComments.unshift(...comments);\n }\n}\n\n/**\n * Merge comments with node's innerComments or assign comments to be\n * innerComments. New comments will be placed before old comments\n * because the commentStack is enumerated reversely.\n *\n * @param {Node} node\n * @param {Array} comments\n */\nexport function setInnerComments(node: Node, comments: Array) {\n if (node.innerComments === undefined) {\n node.innerComments = comments;\n } else {\n node.innerComments.unshift(...comments);\n }\n}\n\n/**\n * Given node and elements array, if elements has non-null element,\n * merge comments to its trailingComments, otherwise merge comments\n * to node's innerComments\n *\n * @param {Node} node\n * @param {Array} elements\n * @param {Array} comments\n */\nfunction adjustInnerComments(\n node: Node,\n elements: Array,\n commentWS: CommentWhitespace,\n) {\n let lastElement = null;\n let i = elements.length;\n while (lastElement === null && i > 0) {\n lastElement = elements[--i];\n }\n if (lastElement === null || lastElement.start > commentWS.start) {\n setInnerComments(node, commentWS.comments);\n } else {\n setTrailingComments(lastElement, commentWS.comments);\n }\n}\n\n/** @class CommentsParser */\nexport default class CommentsParser extends BaseParser {\n addComment(comment: Comment): void {\n if (this.filename) comment.loc.filename = this.filename;\n this.state.comments.push(comment);\n }\n\n /**\n * Given a newly created AST node _n_, attach _n_ to a comment whitespace _w_ if applicable\n * {@see {@link CommentWhitespace}}\n *\n * @param {Node} node\n * @returns {void}\n * @memberof CommentsParser\n */\n processComment(node: Node): void {\n const { commentStack } = this.state;\n const commentStackLength = commentStack.length;\n if (commentStackLength === 0) return;\n let i = commentStackLength - 1;\n const lastCommentWS = commentStack[i];\n\n if (lastCommentWS.start === node.end) {\n lastCommentWS.leadingNode = node;\n i--;\n }\n\n const { start: nodeStart } = node;\n // invariant: for all 0 <= j <= i, let c = commentStack[j], c must satisfy c.end < node.end\n for (; i >= 0; i--) {\n const commentWS = commentStack[i];\n const commentEnd = commentWS.end;\n if (commentEnd > nodeStart) {\n // by definition of commentWhiteSpace, this implies commentWS.start > nodeStart\n // so node can be a containingNode candidate. At this time we can finalize the comment\n // whitespace, because\n // 1) its leadingNode or trailingNode, if exists, will not change\n // 2) its containingNode have been assigned and will not change because it is the\n // innermost minimal-sized AST node\n commentWS.containingNode = node;\n this.finalizeComment(commentWS);\n commentStack.splice(i, 1);\n } else {\n if (commentEnd === nodeStart) {\n commentWS.trailingNode = node;\n }\n // stop the loop when commentEnd <= nodeStart\n break;\n }\n }\n }\n\n /**\n * Assign the comments of comment whitespaces to related AST nodes.\n * Also adjust innerComments following trailing comma.\n *\n * @memberof CommentsParser\n */\n finalizeComment(commentWS: CommentWhitespace) {\n const { comments } = commentWS;\n if (commentWS.leadingNode !== null || commentWS.trailingNode !== null) {\n if (commentWS.leadingNode !== null) {\n setTrailingComments(commentWS.leadingNode, comments);\n }\n if (commentWS.trailingNode !== null) {\n setLeadingComments(commentWS.trailingNode, comments);\n }\n } else {\n /*:: invariant(commentWS.containingNode !== null) */\n const { containingNode: node, start: commentStart } = commentWS;\n if (this.input.charCodeAt(commentStart - 1) === charCodes.comma) {\n // If a commentWhitespace follows a comma and the containingNode allows\n // list structures with trailing comma, merge it to the trailingComment\n // of the last non-null list element\n switch (node.type) {\n case \"ObjectExpression\":\n case \"ObjectPattern\":\n case \"RecordExpression\":\n adjustInnerComments(node, node.properties, commentWS);\n break;\n case \"CallExpression\":\n case \"OptionalCallExpression\":\n adjustInnerComments(node, node.arguments, commentWS);\n break;\n case \"FunctionDeclaration\":\n case \"FunctionExpression\":\n case \"ArrowFunctionExpression\":\n case \"ObjectMethod\":\n case \"ClassMethod\":\n case \"ClassPrivateMethod\":\n adjustInnerComments(node, node.params, commentWS);\n break;\n case \"ArrayExpression\":\n case \"ArrayPattern\":\n case \"TupleExpression\":\n adjustInnerComments(node, node.elements, commentWS);\n break;\n case \"ExportNamedDeclaration\":\n case \"ImportDeclaration\":\n adjustInnerComments(node, node.specifiers, commentWS);\n break;\n default: {\n setInnerComments(node, comments);\n }\n }\n } else {\n setInnerComments(node, comments);\n }\n }\n }\n\n /**\n * Drains remaning commentStack and applies finalizeComment\n * to each comment whitespace. Used only in parseExpression\n * where the top level AST node is _not_ Program\n * {@see {@link CommentsParser#finalizeComment}}\n *\n * @memberof CommentsParser\n */\n finalizeRemainingComments() {\n const { commentStack } = this.state;\n for (let i = commentStack.length - 1; i >= 0; i--) {\n this.finalizeComment(commentStack[i]);\n }\n this.state.commentStack = [];\n }\n\n /**\n * Reset previous node trailing comments. Used in object / class\n * property parsing. We parse `async`, `static`, `set` and `get`\n * as an identifier but may reinterepret it into an async/static/accessor\n * method later. In this case the identifier is not part of the AST and we\n * should sync the knowledge to commentStacks\n *\n * For example, when parsing */\n // async /* 1 */ function f() {}\n /*\n * the comment whitespace \"* 1 *\" has leading node Identifier(async). When\n * we see the function token, we create a Function node and mark \"* 1 *\" as\n * inner comments. So \"* 1 *\" should be detached from the Identifier node.\n *\n * @param {N.Node} node the last finished AST node _before_ current token\n * @returns\n * @memberof CommentsParser\n */\n resetPreviousNodeTrailingComments(node: Node) {\n const { commentStack } = this.state;\n const { length } = commentStack;\n if (length === 0) return;\n const commentWS = commentStack[length - 1];\n if (commentWS.leadingNode === node) {\n commentWS.leadingNode = null;\n }\n }\n\n /**\n * Attach a node to the comment whitespaces right before/after\n * the given range.\n *\n * This is used to properly attach comments around parenthesized\n * expressions as leading/trailing comments of the inner expression.\n *\n * @param {Node} node\n * @param {number} start\n * @param {number} end\n */\n takeSurroundingComments(node: Node, start: number, end: number) {\n const { commentStack } = this.state;\n const commentStackLength = commentStack.length;\n if (commentStackLength === 0) return;\n let i = commentStackLength - 1;\n\n for (; i >= 0; i--) {\n const commentWS = commentStack[i];\n const commentEnd = commentWS.end;\n const commentStart = commentWS.start;\n\n if (commentStart === end) {\n commentWS.leadingNode = node;\n } else if (commentEnd === start) {\n commentWS.trailingNode = node;\n } else if (commentEnd < start) {\n break;\n }\n }\n }\n}\n","// @flow\n\nexport const ErrorCodes = Object.freeze({\n SyntaxError: \"BABEL_PARSER_SYNTAX_ERROR\",\n SourceTypeModuleError: \"BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED\",\n});\n\nexport type ErrorCode = $Values;\n","// @flow\n\nimport { makeErrorTemplates, ErrorCodes } from \"./error\";\n\n/* eslint sort-keys: \"error\" */\n\n/**\n * @module parser/error-message\n */\n\n// The Errors key follows https://cs.chromium.org/chromium/src/v8/src/common/message-template.h unless it does not exist\nexport const ErrorMessages = makeErrorTemplates(\n {\n AccessorIsGenerator: \"A %0ter cannot be a generator.\",\n ArgumentsInClass:\n \"'arguments' is only allowed in functions and class methods.\",\n AsyncFunctionInSingleStatementContext:\n \"Async functions can only be declared at the top level or inside a block.\",\n AwaitBindingIdentifier:\n \"Can not use 'await' as identifier inside an async function.\",\n AwaitBindingIdentifierInStaticBlock:\n \"Can not use 'await' as identifier inside a static block.\",\n AwaitExpressionFormalParameter:\n \"'await' is not allowed in async function parameters.\",\n AwaitNotInAsyncContext:\n \"'await' is only allowed within async functions and at the top levels of modules.\",\n AwaitNotInAsyncFunction: \"'await' is only allowed within async functions.\",\n BadGetterArity: \"A 'get' accesor must not have any formal parameters.\",\n BadSetterArity: \"A 'set' accesor must have exactly one formal parameter.\",\n BadSetterRestParameter:\n \"A 'set' accesor function argument must not be a rest parameter.\",\n ConstructorClassField: \"Classes may not have a field named 'constructor'.\",\n ConstructorClassPrivateField:\n \"Classes may not have a private field named '#constructor'.\",\n ConstructorIsAccessor: \"Class constructor may not be an accessor.\",\n ConstructorIsAsync: \"Constructor can't be an async function.\",\n ConstructorIsGenerator: \"Constructor can't be a generator.\",\n DeclarationMissingInitializer: \"'%0' require an initialization value.\",\n DecoratorBeforeExport:\n \"Decorators must be placed *before* the 'export' keyword. You can set the 'decoratorsBeforeExport' option to false to use the 'export @decorator class {}' syntax.\",\n DecoratorConstructor:\n \"Decorators can't be used with a constructor. Did you mean '@dec class { ... }'?\",\n DecoratorExportClass:\n \"Using the export keyword between a decorator and a class is not allowed. Please use `export @dec class` instead.\",\n DecoratorSemicolon: \"Decorators must not be followed by a semicolon.\",\n DecoratorStaticBlock: \"Decorators can't be used with a static block.\",\n DeletePrivateField: \"Deleting a private field is not allowed.\",\n DestructureNamedImport:\n \"ES2015 named imports do not destructure. Use another statement for destructuring after the import.\",\n DuplicateConstructor: \"Duplicate constructor in the same class.\",\n DuplicateDefaultExport: \"Only one default export allowed per module.\",\n DuplicateExport:\n \"`%0` has already been exported. Exported identifiers must be unique.\",\n DuplicateProto: \"Redefinition of __proto__ property.\",\n DuplicateRegExpFlags: \"Duplicate regular expression flag.\",\n ElementAfterRest: \"Rest element must be last element.\",\n EscapedCharNotAnIdentifier: \"Invalid Unicode escape.\",\n ExportBindingIsString:\n \"A string literal cannot be used as an exported binding without `from`.\\n- Did you mean `export { '%0' as '%1' } from 'some-module'`?\",\n ExportDefaultFromAsIdentifier:\n \"'from' is not allowed as an identifier after 'export default'.\",\n ForInOfLoopInitializer:\n \"'%0' loop variable declaration may not have an initializer.\",\n ForOfAsync: \"The left-hand side of a for-of loop may not be 'async'.\",\n ForOfLet: \"The left-hand side of a for-of loop may not start with 'let'.\",\n GeneratorInSingleStatementContext:\n \"Generators can only be declared at the top level or inside a block.\",\n IllegalBreakContinue: \"Unsyntactic %0.\",\n IllegalLanguageModeDirective:\n \"Illegal 'use strict' directive in function with non-simple parameter list.\",\n IllegalReturn: \"'return' outside of function.\",\n ImportBindingIsString:\n 'A string literal cannot be used as an imported binding.\\n- Did you mean `import { \"%0\" as foo }`?',\n ImportCallArgumentTrailingComma:\n \"Trailing comma is disallowed inside import(...) arguments.\",\n ImportCallArity: \"`import()` requires exactly %0.\",\n ImportCallNotNewExpression: \"Cannot use new with import(...).\",\n ImportCallSpreadArgument: \"`...` is not allowed in `import()`.\",\n IncompatibleRegExpUVFlags:\n \"The 'u' and 'v' regular expression flags cannot be enabled at the same time.\",\n InvalidBigIntLiteral: \"Invalid BigIntLiteral.\",\n InvalidCodePoint: \"Code point out of bounds.\",\n InvalidCoverInitializedName: \"Invalid shorthand property initializer.\",\n InvalidDecimal: \"Invalid decimal.\",\n InvalidDigit: \"Expected number in radix %0.\",\n InvalidEscapeSequence: \"Bad character escape sequence.\",\n InvalidEscapeSequenceTemplate: \"Invalid escape sequence in template.\",\n InvalidEscapedReservedWord: \"Escape sequence in keyword %0.\",\n InvalidIdentifier: \"Invalid identifier %0.\",\n InvalidLhs: \"Invalid left-hand side in %0.\",\n InvalidLhsBinding: \"Binding invalid left-hand side in %0.\",\n InvalidNumber: \"Invalid number.\",\n InvalidOrMissingExponent:\n \"Floating-point numbers require a valid exponent after the 'e'.\",\n InvalidOrUnexpectedToken: \"Unexpected character '%0'.\",\n InvalidParenthesizedAssignment: \"Invalid parenthesized assignment pattern.\",\n InvalidPrivateFieldResolution: \"Private name #%0 is not defined.\",\n InvalidPropertyBindingPattern: \"Binding member expression.\",\n InvalidRecordProperty:\n \"Only properties and spread elements are allowed in record definitions.\",\n InvalidRestAssignmentPattern: \"Invalid rest operator's argument.\",\n LabelRedeclaration: \"Label '%0' is already declared.\",\n LetInLexicalBinding:\n \"'let' is not allowed to be used as a name in 'let' or 'const' declarations.\",\n LineTerminatorBeforeArrow: \"No line break is allowed before '=>'.\",\n MalformedRegExpFlags: \"Invalid regular expression flag.\",\n MissingClassName: \"A class name is required.\",\n MissingEqInAssignment:\n \"Only '=' operator can be used for specifying default value.\",\n MissingSemicolon: \"Missing semicolon.\",\n MissingUnicodeEscape: \"Expecting Unicode escape sequence \\\\uXXXX.\",\n MixingCoalesceWithLogical:\n \"Nullish coalescing operator(??) requires parens when mixing with logical operators.\",\n ModuleAttributeDifferentFromType:\n \"The only accepted module attribute is `type`.\",\n ModuleAttributeInvalidValue:\n \"Only string literals are allowed as module attribute values.\",\n ModuleAttributesWithDuplicateKeys:\n 'Duplicate key \"%0\" is not allowed in module attributes.',\n ModuleExportNameHasLoneSurrogate:\n \"An export name cannot include a lone surrogate, found '\\\\u%0'.\",\n ModuleExportUndefined: \"Export '%0' is not defined.\",\n MultipleDefaultsInSwitch: \"Multiple default clauses.\",\n NewlineAfterThrow: \"Illegal newline after throw.\",\n NoCatchOrFinally: \"Missing catch or finally clause.\",\n NumberIdentifier: \"Identifier directly after number.\",\n NumericSeparatorInEscapeSequence:\n \"Numeric separators are not allowed inside unicode escape sequences or hex escape sequences.\",\n ObsoleteAwaitStar:\n \"'await*' has been removed from the async functions proposal. Use Promise.all() instead.\",\n OptionalChainingNoNew:\n \"Constructors in/after an Optional Chain are not allowed.\",\n OptionalChainingNoTemplate:\n \"Tagged Template Literals are not allowed in optionalChain.\",\n OverrideOnConstructor:\n \"'override' modifier cannot appear on a constructor declaration.\",\n ParamDupe: \"Argument name clash.\",\n PatternHasAccessor: \"Object pattern can't contain getter or setter.\",\n PatternHasMethod: \"Object pattern can't contain methods.\",\n // This error is only used by the smart-mix proposal\n PipeBodyIsTighter:\n \"Unexpected %0 after pipeline body; any %0 expression acting as Hack-style pipe body must be parenthesized due to its loose operator precedence.\",\n PipeTopicRequiresHackPipes:\n 'Topic reference is used, but the pipelineOperator plugin was not passed a \"proposal\": \"hack\" or \"smart\" option.',\n PipeTopicUnbound:\n \"Topic reference is unbound; it must be inside a pipe body.\",\n PipeTopicUnconfiguredToken:\n 'Invalid topic token %0. In order to use %0 as a topic reference, the pipelineOperator plugin must be configured with { \"proposal\": \"hack\", \"topicToken\": \"%0\" }.',\n PipeTopicUnused:\n \"Hack-style pipe body does not contain a topic reference; Hack-style pipes must use topic at least once.\",\n PipeUnparenthesizedBody:\n \"Hack-style pipe body cannot be an unparenthesized %0 expression; please wrap it in parentheses.\",\n\n // Messages whose codes start with “Pipeline” or “PrimaryTopic”\n // are retained for backwards compatibility\n // with the deprecated smart-mix pipe operator proposal plugin.\n // They are subject to removal in a future major version.\n PipelineBodyNoArrow:\n 'Unexpected arrow \"=>\" after pipeline body; arrow function in pipeline body must be parenthesized.',\n PipelineBodySequenceExpression:\n \"Pipeline body may not be a comma-separated sequence expression.\",\n PipelineHeadSequenceExpression:\n \"Pipeline head should not be a comma-separated sequence expression.\",\n PipelineTopicUnused:\n \"Pipeline is in topic style but does not use topic reference.\",\n PrimaryTopicNotAllowed:\n \"Topic reference was used in a lexical context without topic binding.\",\n PrimaryTopicRequiresSmartPipeline:\n 'Topic reference is used, but the pipelineOperator plugin was not passed a \"proposal\": \"hack\" or \"smart\" option.',\n\n PrivateInExpectedIn:\n \"Private names are only allowed in property accesses (`obj.#%0`) or in `in` expressions (`#%0 in obj`).\",\n PrivateNameRedeclaration: \"Duplicate private name #%0.\",\n RecordExpressionBarIncorrectEndSyntaxType:\n \"Record expressions ending with '|}' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'.\",\n RecordExpressionBarIncorrectStartSyntaxType:\n \"Record expressions starting with '{|' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'.\",\n RecordExpressionHashIncorrectStartSyntaxType:\n \"Record expressions starting with '#{' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'hash'.\",\n RecordNoProto: \"'__proto__' is not allowed in Record expressions.\",\n RestTrailingComma: \"Unexpected trailing comma after rest element.\",\n SloppyFunction:\n \"In non-strict mode code, functions can only be declared at top level, inside a block, or as the body of an if statement.\",\n StaticPrototype: \"Classes may not have static property named prototype.\",\n StrictDelete: \"Deleting local variable in strict mode.\",\n StrictEvalArguments: \"Assigning to '%0' in strict mode.\",\n StrictEvalArgumentsBinding: \"Binding '%0' in strict mode.\",\n StrictFunction:\n \"In strict mode code, functions can only be declared at top level or inside a block.\",\n StrictNumericEscape:\n \"The only valid numeric escape in strict mode is '\\\\0'.\",\n StrictOctalLiteral: \"Legacy octal literals are not allowed in strict mode.\",\n StrictWith: \"'with' in strict mode.\",\n SuperNotAllowed:\n \"`super()` is only valid inside a class constructor of a subclass. Maybe a typo in the method name ('constructor') or not extending another class?\",\n SuperPrivateField: \"Private fields can't be accessed on super.\",\n TrailingDecorator: \"Decorators must be attached to a class element.\",\n TupleExpressionBarIncorrectEndSyntaxType:\n \"Tuple expressions ending with '|]' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'.\",\n TupleExpressionBarIncorrectStartSyntaxType:\n \"Tuple expressions starting with '[|' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'.\",\n TupleExpressionHashIncorrectStartSyntaxType:\n \"Tuple expressions starting with '#[' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'hash'.\",\n UnexpectedArgumentPlaceholder: \"Unexpected argument placeholder.\",\n UnexpectedAwaitAfterPipelineBody:\n 'Unexpected \"await\" after pipeline body; await must have parentheses in minimal proposal.',\n UnexpectedDigitAfterHash: \"Unexpected digit after hash token.\",\n UnexpectedImportExport:\n \"'import' and 'export' may only appear at the top level.\",\n UnexpectedKeyword: \"Unexpected keyword '%0'.\",\n UnexpectedLeadingDecorator:\n \"Leading decorators must be attached to a class declaration.\",\n UnexpectedLexicalDeclaration:\n \"Lexical declaration cannot appear in a single-statement context.\",\n UnexpectedNewTarget:\n \"`new.target` can only be used in functions or class properties.\",\n UnexpectedNumericSeparator:\n \"A numeric separator is only allowed between two digits.\",\n UnexpectedPrivateField: \"Unexpected private name.\",\n UnexpectedReservedWord: \"Unexpected reserved word '%0'.\",\n UnexpectedSuper: \"'super' is only allowed in object methods and classes.\",\n UnexpectedToken: \"Unexpected token '%0'.\",\n UnexpectedTokenUnaryExponentiation:\n \"Illegal expression. Wrap left hand side or entire exponentiation in parentheses.\",\n UnsupportedBind: \"Binding should be performed on object property.\",\n UnsupportedDecoratorExport:\n \"A decorated export must export a class declaration.\",\n UnsupportedDefaultExport:\n \"Only expressions, functions or classes are allowed as the `default` export.\",\n UnsupportedImport:\n \"`import` can only be used in `import()` or `import.meta`.\",\n UnsupportedMetaProperty: \"The only valid meta property for %0 is %0.%1.\",\n UnsupportedParameterDecorator:\n \"Decorators cannot be used to decorate parameters.\",\n UnsupportedPropertyDecorator:\n \"Decorators cannot be used to decorate object literal properties.\",\n UnsupportedSuper:\n \"'super' can only be used with function calls (i.e. super()) or in property accesses (i.e. super.prop or super[prop]).\",\n UnterminatedComment: \"Unterminated comment.\",\n UnterminatedRegExp: \"Unterminated regular expression.\",\n UnterminatedString: \"Unterminated string constant.\",\n UnterminatedTemplate: \"Unterminated template.\",\n VarRedeclaration: \"Identifier '%0' has already been declared.\",\n YieldBindingIdentifier:\n \"Can not use 'yield' as identifier inside a generator.\",\n YieldInParameter: \"Yield expression is not allowed in formal parameters.\",\n ZeroDigitNumericSeparator:\n \"Numeric separator can not be used after leading 0.\",\n },\n /* code */ ErrorCodes.SyntaxError,\n);\n\nexport const SourceTypeModuleErrorMessages = makeErrorTemplates(\n {\n ImportMetaOutsideModule: `import.meta may appear only with 'sourceType: \"module\"'`,\n ImportOutsideModule: `'import' and 'export' may appear only with 'sourceType: \"module\"'`,\n },\n /* code */ ErrorCodes.SourceTypeModuleError,\n);\n","// @flow\n/* eslint sort-keys: \"error\" */\nimport { type Position } from \"../util/location\";\nimport CommentsParser from \"./comments\";\nimport { type ErrorCode, ErrorCodes } from \"./error-codes\";\nimport { type Node } from \"../types\";\n\n// This function is used to raise exceptions on parse errors. It\n// takes an offset integer (into the current `input`) to indicate\n// the location of the error, attaches the position to the end\n// of the error message, and then raises a `SyntaxError` with that\n// message.\n\ntype ErrorContext = {\n pos: number,\n loc: Position,\n missingPlugin?: Array,\n code?: string,\n reasonCode?: String,\n};\nexport type ParsingError = SyntaxError & ErrorContext;\n\nexport type ErrorTemplate = {\n code: ErrorCode,\n template: string,\n reasonCode: string,\n};\nexport type ErrorTemplates = {\n [key: string]: ErrorTemplate,\n};\n\ntype Origin = {| node: Node |} | {| at: Position |};\n\ntype SyntaxPlugin =\n | \"flow\"\n | \"typescript\"\n | \"jsx\"\n | \"placeholders\"\n | typeof undefined;\n\nfunction keepReasonCodeCompat(reasonCode: string, syntaxPlugin: SyntaxPlugin) {\n if (!process.env.BABEL_8_BREAKING) {\n // For consistency in TypeScript and Flow error codes\n if (syntaxPlugin === \"flow\" && reasonCode === \"PatternIsOptional\") {\n return \"OptionalBindingPattern\";\n }\n }\n return reasonCode;\n}\n\nexport function makeErrorTemplates(\n messages: {\n [key: string]: string,\n },\n code: ErrorCode,\n syntaxPlugin?: SyntaxPlugin,\n): ErrorTemplates {\n const templates: ErrorTemplates = {};\n Object.keys(messages).forEach(reasonCode => {\n templates[reasonCode] = Object.freeze({\n code,\n reasonCode: keepReasonCodeCompat(reasonCode, syntaxPlugin),\n template: messages[reasonCode],\n });\n });\n return Object.freeze(templates);\n}\n\nexport { ErrorCodes };\nexport {\n ErrorMessages as Errors,\n SourceTypeModuleErrorMessages as SourceTypeModuleErrors,\n} from \"./error-message\";\n\nexport type raiseFunction = (ErrorTemplate, Origin, ...any) => void;\nexport type ErrorData = {| message: ErrorTemplate, loc: Position |};\n\nexport default class ParserError extends CommentsParser {\n // Forward-declaration: defined in tokenizer/index.js\n /*::\n +isLookahead: boolean;\n */\n\n raise(\n { code, reasonCode, template }: ErrorTemplate,\n origin: Origin,\n ...params: any\n ): Error | empty {\n return this.raiseWithData(\n origin.node ? origin.node.loc.start : origin.at,\n { code, reasonCode },\n template,\n ...params,\n );\n }\n\n /**\n * Raise a parsing error on given position pos. If errorRecovery is true,\n * it will first search current errors and overwrite the error thrown on the exact\n * position before with the new error message. If errorRecovery is false, it\n * fallbacks to `raise`.\n *\n * @param {number} pos\n * @param {string} errorTemplate\n * @param {...any} params\n * @returns {(Error | empty)}\n * @memberof ParserError\n */\n raiseOverwrite(\n loc: Position,\n { code, template }: ErrorTemplate,\n ...params: any\n ): Error | empty {\n const pos = loc.index;\n const message =\n template.replace(/%(\\d+)/g, (_, i: number) => params[i]) +\n ` (${loc.line}:${loc.column})`;\n if (this.options.errorRecovery) {\n const errors = this.state.errors;\n for (let i = errors.length - 1; i >= 0; i--) {\n const error = errors[i];\n if (error.pos === pos) {\n return Object.assign(error, { message });\n } else if (error.pos < pos) {\n break;\n }\n }\n }\n return this._raise({ code, loc, pos }, message);\n }\n\n raiseWithData(\n loc: Position,\n data?: {\n missingPlugin?: Array,\n code?: string,\n },\n errorTemplate: string,\n ...params: any\n ): Error | empty {\n const pos = loc.index;\n const message =\n errorTemplate.replace(/%(\\d+)/g, (_, i: number) => params[i]) +\n ` (${loc.line}:${loc.column})`;\n return this._raise(Object.assign(({ loc, pos }: Object), data), message);\n }\n\n _raise(errorContext: ErrorContext, message: string): Error | empty {\n // $FlowIgnore\n const err: SyntaxError & ErrorContext = new SyntaxError(message);\n Object.assign(err, errorContext);\n if (this.options.errorRecovery) {\n if (!this.isLookahead) this.state.errors.push(err);\n return err;\n } else {\n throw err;\n }\n }\n}\n","// @flow\n\nimport { type TokenType } from \"../tokenizer/types\";\nimport type Parser from \"../parser\";\nimport type { ExpressionErrors } from \"../parser/util\";\nimport * as N from \"../types\";\nimport type { Node as NodeType, NodeBase, File } from \"../types\";\nimport type { Position } from \"../util/location\";\nimport { Errors } from \"../parser/error\";\n\nconst { defineProperty } = Object;\nconst toUnenumerable = (object, key) =>\n defineProperty(object, key, { enumerable: false, value: object[key] });\n\nfunction toESTreeLocation(node: any) {\n toUnenumerable(node.loc.start, \"index\");\n toUnenumerable(node.loc.end, \"index\");\n\n return node;\n}\n\nexport default (superClass: Class): Class =>\n class extends superClass {\n parse(): File {\n const file = toESTreeLocation(super.parse());\n\n if (this.options.tokens) {\n file.tokens = file.tokens.map(toESTreeLocation);\n }\n\n return file;\n }\n\n parseRegExpLiteral({ pattern, flags }): N.Node {\n let regex = null;\n try {\n regex = new RegExp(pattern, flags);\n } catch (e) {\n // In environments that don't support these flags value will\n // be null as the regex can't be represented natively.\n }\n const node = this.estreeParseLiteral(regex);\n node.regex = { pattern, flags };\n\n return node;\n }\n\n parseBigIntLiteral(value: any): N.Node {\n // https://github.com/estree/estree/blob/master/es2020.md#bigintliteral\n let bigInt;\n try {\n // $FlowIgnore\n bigInt = BigInt(value);\n } catch {\n bigInt = null;\n }\n const node = this.estreeParseLiteral(bigInt);\n node.bigint = String(node.value || value);\n\n return node;\n }\n\n parseDecimalLiteral(value: any): N.Node {\n // https://github.com/estree/estree/blob/master/experimental/decimal.md\n // todo: use BigDecimal when node supports it.\n const decimal = null;\n const node = this.estreeParseLiteral(decimal);\n node.decimal = String(node.value || value);\n\n return node;\n }\n\n estreeParseLiteral(value: any) {\n return this.parseLiteral(value, \"Literal\");\n }\n\n parseStringLiteral(value: any): N.Node {\n return this.estreeParseLiteral(value);\n }\n\n parseNumericLiteral(value: any): any {\n return this.estreeParseLiteral(value);\n }\n\n parseNullLiteral(): N.Node {\n return this.estreeParseLiteral(null);\n }\n\n parseBooleanLiteral(value: boolean): N.BooleanLiteral {\n return this.estreeParseLiteral(value);\n }\n\n directiveToStmt(directive: N.Directive): N.ExpressionStatement {\n const directiveLiteral = directive.value;\n\n const stmt = this.startNodeAt(directive.start, directive.loc.start);\n const expression = this.startNodeAt(\n directiveLiteral.start,\n directiveLiteral.loc.start,\n );\n\n expression.value = directiveLiteral.extra.expressionValue;\n expression.raw = directiveLiteral.extra.raw;\n\n stmt.expression = this.finishNodeAt(\n expression,\n \"Literal\",\n directiveLiteral.loc.end,\n );\n stmt.directive = directiveLiteral.extra.raw.slice(1, -1);\n\n return this.finishNodeAt(stmt, \"ExpressionStatement\", directive.loc.end);\n }\n\n // ==================================\n // Overrides\n // ==================================\n\n initFunction(\n node: N.BodilessFunctionOrMethodBase,\n isAsync: ?boolean,\n ): void {\n super.initFunction(node, isAsync);\n node.expression = false;\n }\n\n checkDeclaration(node: N.Pattern | N.ObjectProperty): void {\n if (node != null && this.isObjectProperty(node)) {\n this.checkDeclaration(((node: any): N.EstreeProperty).value);\n } else {\n super.checkDeclaration(node);\n }\n }\n\n getObjectOrClassMethodParams(method: N.ObjectMethod | N.ClassMethod) {\n return ((method: any): N.EstreeProperty | N.EstreeMethodDefinition).value\n .params;\n }\n\n isValidDirective(stmt: N.Statement): boolean {\n return (\n stmt.type === \"ExpressionStatement\" &&\n stmt.expression.type === \"Literal\" &&\n typeof stmt.expression.value === \"string\" &&\n !stmt.expression.extra?.parenthesized\n );\n }\n\n parseBlockBody(\n node: N.BlockStatementLike,\n ...args: [?boolean, boolean, TokenType, void | (boolean => void)]\n ): void {\n super.parseBlockBody(node, ...args);\n\n const directiveStatements = node.directives.map(d =>\n this.directiveToStmt(d),\n );\n node.body = directiveStatements.concat(node.body);\n // $FlowIgnore - directives isn't optional in the type definition\n delete node.directives;\n }\n\n pushClassMethod(\n classBody: N.ClassBody,\n method: N.ClassMethod,\n isGenerator: boolean,\n isAsync: boolean,\n isConstructor: boolean,\n allowsDirectSuper: boolean,\n ): void {\n this.parseMethod(\n method,\n isGenerator,\n isAsync,\n isConstructor,\n allowsDirectSuper,\n \"ClassMethod\",\n true,\n );\n if (method.typeParameters) {\n // $FlowIgnore\n method.value.typeParameters = method.typeParameters;\n delete method.typeParameters;\n }\n classBody.body.push(method);\n }\n\n parsePrivateName(): any {\n const node = super.parsePrivateName();\n if (!process.env.BABEL_8_BREAKING) {\n if (!this.getPluginOption(\"estree\", \"classFeatures\")) {\n return node;\n }\n }\n return this.convertPrivateNameToPrivateIdentifier(node);\n }\n\n convertPrivateNameToPrivateIdentifier(\n node: N.PrivateName,\n ): N.EstreePrivateIdentifier {\n const name = super.getPrivateNameSV(node);\n node = (node: any);\n delete node.id;\n node.name = name;\n node.type = \"PrivateIdentifier\";\n return node;\n }\n\n isPrivateName(node: N.Node): boolean {\n if (!process.env.BABEL_8_BREAKING) {\n if (!this.getPluginOption(\"estree\", \"classFeatures\")) {\n return super.isPrivateName(node);\n }\n }\n return node.type === \"PrivateIdentifier\";\n }\n\n getPrivateNameSV(node: N.Node): string {\n if (!process.env.BABEL_8_BREAKING) {\n if (!this.getPluginOption(\"estree\", \"classFeatures\")) {\n return super.getPrivateNameSV(node);\n }\n }\n return node.name;\n }\n\n parseLiteral(value: any, type: $ElementType): T {\n const node = super.parseLiteral(value, type);\n node.raw = node.extra.raw;\n delete node.extra;\n\n return node;\n }\n\n parseFunctionBody(\n node: N.Function,\n allowExpression: ?boolean,\n isMethod?: boolean = false,\n ): void {\n super.parseFunctionBody(node, allowExpression, isMethod);\n node.expression = node.body.type !== \"BlockStatement\";\n }\n\n parseMethod(\n node: T,\n isGenerator: boolean,\n isAsync: boolean,\n isConstructor: boolean,\n allowDirectSuper: boolean,\n type: string,\n inClassScope: boolean = false,\n ): T {\n let funcNode = this.startNode();\n funcNode.kind = node.kind; // provide kind, so super method correctly sets state\n funcNode = super.parseMethod(\n funcNode,\n isGenerator,\n isAsync,\n isConstructor,\n allowDirectSuper,\n type,\n inClassScope,\n );\n funcNode.type = \"FunctionExpression\";\n delete funcNode.kind;\n // $FlowIgnore\n node.value = funcNode;\n if (type === \"ClassPrivateMethod\") {\n // $FlowIgnore\n node.computed = false;\n }\n type = \"MethodDefinition\";\n return this.finishNode(node, type);\n }\n\n parseClassProperty(...args: [N.ClassProperty]): any {\n const propertyNode = (super.parseClassProperty(...args): any);\n if (!process.env.BABEL_8_BREAKING) {\n if (!this.getPluginOption(\"estree\", \"classFeatures\")) {\n return (propertyNode: N.EstreePropertyDefinition);\n }\n }\n propertyNode.type = \"PropertyDefinition\";\n return (propertyNode: N.EstreePropertyDefinition);\n }\n\n parseClassPrivateProperty(...args: [N.ClassPrivateProperty]): any {\n const propertyNode = (super.parseClassPrivateProperty(...args): any);\n if (!process.env.BABEL_8_BREAKING) {\n if (!this.getPluginOption(\"estree\", \"classFeatures\")) {\n return (propertyNode: N.EstreePropertyDefinition);\n }\n }\n propertyNode.type = \"PropertyDefinition\";\n propertyNode.computed = false;\n return (propertyNode: N.EstreePropertyDefinition);\n }\n\n parseObjectMethod(\n prop: N.ObjectMethod,\n isGenerator: boolean,\n isAsync: boolean,\n isPattern: boolean,\n isAccessor: boolean,\n ): ?N.ObjectMethod {\n const node: N.EstreeProperty = (super.parseObjectMethod(\n prop,\n isGenerator,\n isAsync,\n isPattern,\n isAccessor,\n ): any);\n\n if (node) {\n node.type = \"Property\";\n if (((node: any): N.ClassMethod).kind === \"method\") node.kind = \"init\";\n node.shorthand = false;\n }\n\n return (node: any);\n }\n\n parseObjectProperty(\n prop: N.ObjectProperty,\n startPos: ?number,\n startLoc: ?Position,\n isPattern: boolean,\n refExpressionErrors: ?ExpressionErrors,\n ): ?N.ObjectProperty {\n const node: N.EstreeProperty = (super.parseObjectProperty(\n prop,\n startPos,\n startLoc,\n isPattern,\n refExpressionErrors,\n ): any);\n\n if (node) {\n node.kind = \"init\";\n node.type = \"Property\";\n }\n\n return (node: any);\n }\n\n isAssignable(node: N.Node, isBinding?: boolean): boolean {\n if (node != null && this.isObjectProperty(node)) {\n return this.isAssignable(node.value, isBinding);\n }\n return super.isAssignable(node, isBinding);\n }\n\n toAssignable(node: N.Node, isLHS: boolean = false): N.Node {\n if (node != null && this.isObjectProperty(node)) {\n const { key, value } = node;\n if (this.isPrivateName(key)) {\n this.classScope.usePrivateName(\n this.getPrivateNameSV(key),\n key.loc.start,\n );\n }\n this.toAssignable(value, isLHS);\n return node;\n }\n\n return super.toAssignable(node, isLHS);\n }\n\n toAssignableObjectExpressionProp(prop: N.Node, ...args) {\n if (prop.kind === \"get\" || prop.kind === \"set\") {\n this.raise(Errors.PatternHasAccessor, { node: prop.key });\n } else if (prop.method) {\n this.raise(Errors.PatternHasMethod, { node: prop.key });\n } else {\n super.toAssignableObjectExpressionProp(prop, ...args);\n }\n }\n\n finishCallExpression(\n node: T,\n optional: boolean,\n ): N.Expression {\n super.finishCallExpression(node, optional);\n\n if (node.callee.type === \"Import\") {\n ((node: N.Node): N.EstreeImportExpression).type = \"ImportExpression\";\n ((node: N.Node): N.EstreeImportExpression).source = node.arguments[0];\n if (this.hasPlugin(\"importAssertions\")) {\n ((node: N.Node): N.EstreeImportExpression).attributes =\n node.arguments[1] ?? null;\n }\n // $FlowIgnore - arguments isn't optional in the type definition\n delete node.arguments;\n // $FlowIgnore - callee isn't optional in the type definition\n delete node.callee;\n }\n\n return node;\n }\n\n toReferencedArguments(\n node:\n | N.CallExpression\n | N.OptionalCallExpression\n | N.EstreeImportExpression,\n /* isParenthesizedExpr?: boolean, */\n ) {\n // ImportExpressions do not have an arguments array.\n if (node.type === \"ImportExpression\") {\n return;\n }\n\n super.toReferencedArguments(node);\n }\n\n parseExport(node: N.Node) {\n super.parseExport(node);\n\n switch (node.type) {\n case \"ExportAllDeclaration\":\n node.exported = null;\n break;\n\n case \"ExportNamedDeclaration\":\n if (\n node.specifiers.length === 1 &&\n node.specifiers[0].type === \"ExportNamespaceSpecifier\"\n ) {\n node.type = \"ExportAllDeclaration\";\n node.exported = node.specifiers[0].exported;\n delete node.specifiers;\n }\n\n break;\n }\n\n return node;\n }\n\n parseSubscript(\n base: N.Expression,\n startPos: number,\n startLoc: Position,\n noCalls: ?boolean,\n state: N.ParseSubscriptState,\n ) {\n const node = super.parseSubscript(\n base,\n startPos,\n startLoc,\n noCalls,\n state,\n );\n\n if (state.optionalChainMember) {\n // https://github.com/estree/estree/blob/master/es2020.md#chainexpression\n if (\n node.type === \"OptionalMemberExpression\" ||\n node.type === \"OptionalCallExpression\"\n ) {\n node.type = node.type.substring(8); // strip Optional prefix\n }\n if (state.stop) {\n const chain = this.startNodeAtNode(node);\n chain.expression = node;\n return this.finishNode(chain, \"ChainExpression\");\n }\n } else if (\n node.type === \"MemberExpression\" ||\n node.type === \"CallExpression\"\n ) {\n node.optional = false;\n }\n\n return node;\n }\n\n hasPropertyAsPrivateName(node: N.Node): boolean {\n if (node.type === \"ChainExpression\") {\n node = node.expression;\n }\n return super.hasPropertyAsPrivateName(node);\n }\n\n isOptionalChain(node: N.Node): boolean {\n return node.type === \"ChainExpression\";\n }\n\n isObjectProperty(node: N.Node): boolean {\n return node.type === \"Property\" && node.kind === \"init\" && !node.method;\n }\n\n isObjectMethod(node: N.Node): boolean {\n return node.method || node.kind === \"get\" || node.kind === \"set\";\n }\n\n finishNodeAt(node: T, type: string, endLoc: Position): T {\n return toESTreeLocation(super.finishNodeAt(node, type, endLoc));\n }\n\n resetEndLocation(\n node: NodeBase,\n endLoc?: Position = this.state.lastTokEndLoc,\n ): void {\n super.resetEndLocation(node, endLoc);\n toESTreeLocation(node);\n }\n };\n","// @flow\n\n// The token context is used in JSX plugin to track\n// jsx tag / jsx text / normal JavaScript expression\n\nexport class TokContext {\n constructor(token: string, preserveSpace?: boolean) {\n this.token = token;\n this.preserveSpace = !!preserveSpace;\n }\n\n token: string;\n preserveSpace: boolean;\n}\n\nconst types: {\n [key: string]: TokContext,\n} = {\n brace: new TokContext(\"{\"), // normal JavaScript expression\n j_oTag: new TokContext(\"...\", true), // JSX expressions\n};\n\nif (!process.env.BABEL_8_BREAKING) {\n types.template = new TokContext(\"`\", true);\n}\n\nexport { types };\n","// @flow\nimport { types as tc, type TokContext } from \"./context\";\n// ## Token types\n\n// The assignment of fine-grained, information-carrying type objects\n// allows the tokenizer to store the information it has about a\n// token in a way that is very cheap for the parser to look up.\n\n// All token type variables start with an underscore, to make them\n// easy to recognize.\n\n// The `beforeExpr` property is used to disambiguate between 1) binary\n// expression (<) and JSX Tag start (); 2) object literal and JSX\n// texts. It is set on the `updateContext` function in the JSX plugin.\n\n// The `startsExpr` property is used to determine whether an expression\n// may be the “argument” subexpression of a `yield` expression or\n// `yield` statement. It is set on all token types that may be at the\n// start of a subexpression.\n\n// `isLoop` marks a keyword as starting a loop, which is important\n// to know when parsing a label, in order to allow or disallow\n// continue jumps to that label.\n\nconst beforeExpr = true;\nconst startsExpr = true;\nconst isLoop = true;\nconst isAssign = true;\nconst prefix = true;\nconst postfix = true;\n\ntype TokenOptions = {\n keyword?: string,\n beforeExpr?: boolean,\n startsExpr?: boolean,\n rightAssociative?: boolean,\n isLoop?: boolean,\n isAssign?: boolean,\n prefix?: boolean,\n postfix?: boolean,\n binop?: ?number,\n};\n\n// Internally the tokenizer stores token as a number\nexport opaque type TokenType = number;\n\n// The `ExportedTokenType` is exported via `tokTypes` and accessible\n// when `tokens: true` is enabled. Unlike internal token type, it provides\n// metadata of the tokens.\nexport class ExportedTokenType {\n label: string;\n keyword: ?string;\n beforeExpr: boolean;\n startsExpr: boolean;\n rightAssociative: boolean;\n isLoop: boolean;\n isAssign: boolean;\n prefix: boolean;\n postfix: boolean;\n binop: ?number;\n // todo(Babel 8): remove updateContext from exposed token layout\n declare updateContext: ?(context: Array) => void;\n\n constructor(label: string, conf: TokenOptions = {}) {\n this.label = label;\n this.keyword = conf.keyword;\n this.beforeExpr = !!conf.beforeExpr;\n this.startsExpr = !!conf.startsExpr;\n this.rightAssociative = !!conf.rightAssociative;\n this.isLoop = !!conf.isLoop;\n this.isAssign = !!conf.isAssign;\n this.prefix = !!conf.prefix;\n this.postfix = !!conf.postfix;\n this.binop = conf.binop != null ? conf.binop : null;\n if (!process.env.BABEL_8_BREAKING) {\n this.updateContext = null;\n }\n }\n}\n\n// A map from keyword/keyword-like string value to the token type\nexport const keywords = new Map();\n\nfunction createKeyword(name: string, options: TokenOptions = {}): TokenType {\n options.keyword = name;\n const token = createToken(name, options);\n keywords.set(name, token);\n return token;\n}\n\nfunction createBinop(name: string, binop: number) {\n return createToken(name, { beforeExpr, binop });\n}\n\nlet tokenTypeCounter = -1;\nexport const tokenTypes: ExportedTokenType[] = [];\nconst tokenLabels: string[] = [];\nconst tokenBinops: number[] = [];\nconst tokenBeforeExprs: boolean[] = [];\nconst tokenStartsExprs: boolean[] = [];\nconst tokenPrefixes: boolean[] = [];\n\nfunction createToken(name: string, options: TokenOptions = {}): TokenType {\n ++tokenTypeCounter;\n tokenLabels.push(name);\n tokenBinops.push(options.binop ?? -1);\n tokenBeforeExprs.push(options.beforeExpr ?? false);\n tokenStartsExprs.push(options.startsExpr ?? false);\n tokenPrefixes.push(options.prefix ?? false);\n tokenTypes.push(new ExportedTokenType(name, options));\n\n return tokenTypeCounter;\n}\n\nfunction createKeywordLike(\n name: string,\n options: TokenOptions = {},\n): TokenType {\n ++tokenTypeCounter;\n keywords.set(name, tokenTypeCounter);\n tokenLabels.push(name);\n tokenBinops.push(options.binop ?? -1);\n tokenBeforeExprs.push(options.beforeExpr ?? false);\n tokenStartsExprs.push(options.startsExpr ?? false);\n tokenPrefixes.push(options.prefix ?? false);\n // In the exported token type, we set the label as \"name\" for backward compatibility with Babel 7\n tokenTypes.push(new ExportedTokenType(\"name\", options));\n\n return tokenTypeCounter;\n}\n\n// For performance the token type helpers depend on the following declarations order.\n// When adding new token types, please also check if the token helpers need update.\n\nexport const tt: { [name: string]: TokenType } = {\n // Punctuation token types.\n bracketL: createToken(\"[\", { beforeExpr, startsExpr }),\n bracketHashL: createToken(\"#[\", { beforeExpr, startsExpr }),\n bracketBarL: createToken(\"[|\", { beforeExpr, startsExpr }),\n bracketR: createToken(\"]\"),\n bracketBarR: createToken(\"|]\"),\n braceL: createToken(\"{\", { beforeExpr, startsExpr }),\n braceBarL: createToken(\"{|\", { beforeExpr, startsExpr }),\n braceHashL: createToken(\"#{\", { beforeExpr, startsExpr }),\n braceR: createToken(\"}\", { beforeExpr }),\n braceBarR: createToken(\"|}\"),\n parenL: createToken(\"(\", { beforeExpr, startsExpr }),\n parenR: createToken(\")\"),\n comma: createToken(\",\", { beforeExpr }),\n semi: createToken(\";\", { beforeExpr }),\n colon: createToken(\":\", { beforeExpr }),\n doubleColon: createToken(\"::\", { beforeExpr }),\n dot: createToken(\".\"),\n question: createToken(\"?\", { beforeExpr }),\n questionDot: createToken(\"?.\"),\n arrow: createToken(\"=>\", { beforeExpr }),\n template: createToken(\"template\"),\n ellipsis: createToken(\"...\", { beforeExpr }),\n backQuote: createToken(\"`\", { startsExpr }),\n dollarBraceL: createToken(\"${\", { beforeExpr, startsExpr }),\n // start: isTemplate\n templateTail: createToken(\"...`\", { startsExpr }),\n templateNonTail: createToken(\"...${\", { beforeExpr, startsExpr }),\n // end: isTemplate\n at: createToken(\"@\"),\n hash: createToken(\"#\", { startsExpr }),\n\n // Special hashbang token.\n interpreterDirective: createToken(\"#!...\"),\n\n // Operators. These carry several kinds of properties to help the\n // parser use them properly (the presence of these properties is\n // what categorizes them as operators).\n //\n // `binop`, when present, specifies that this operator is a binary\n // operator, and will refer to its precedence.\n //\n // `prefix` and `postfix` mark the operator as a prefix or postfix\n // unary operator.\n //\n // `isAssign` marks all of `=`, `+=`, `-=` etcetera, which act as\n // binary operators with a very low precedence, that should result\n // in AssignmentExpression nodes.\n\n // start: isAssign\n eq: createToken(\"=\", { beforeExpr, isAssign }),\n assign: createToken(\"_=\", { beforeExpr, isAssign }),\n slashAssign: createToken(\"_=\", { beforeExpr, isAssign }),\n // These are only needed to support % and ^ as a Hack-pipe topic token.\n // When the proposal settles on a token, the others can be merged with\n // tt.assign.\n xorAssign: createToken(\"_=\", { beforeExpr, isAssign }),\n moduloAssign: createToken(\"_=\", { beforeExpr, isAssign }),\n // end: isAssign\n\n incDec: createToken(\"++/--\", { prefix, postfix, startsExpr }),\n bang: createToken(\"!\", { beforeExpr, prefix, startsExpr }),\n tilde: createToken(\"~\", { beforeExpr, prefix, startsExpr }),\n\n // More possible topic tokens.\n // When the proposal settles on a token, at least one of these may be removed.\n doubleCaret: createToken(\"^^\", { startsExpr }),\n doubleAt: createToken(\"@@\", { startsExpr }),\n\n // start: isBinop\n pipeline: createBinop(\"|>\", 0),\n nullishCoalescing: createBinop(\"??\", 1),\n logicalOR: createBinop(\"||\", 1),\n logicalAND: createBinop(\"&&\", 2),\n bitwiseOR: createBinop(\"|\", 3),\n bitwiseXOR: createBinop(\"^\", 4),\n bitwiseAND: createBinop(\"&\", 5),\n equality: createBinop(\"==/!=/===/!==\", 6),\n lt: createBinop(\"/<=/>=\", 7),\n gt: createBinop(\"/<=/>=\", 7),\n relational: createBinop(\"/<=/>=\", 7),\n bitShift: createBinop(\"<>/>>>\", 8),\n bitShiftL: createBinop(\"<>/>>>\", 8),\n bitShiftR: createBinop(\"<>/>>>\", 8),\n plusMin: createToken(\"+/-\", { beforeExpr, binop: 9, prefix, startsExpr }),\n // startsExpr: required by v8intrinsic plugin\n modulo: createToken(\"%\", { binop: 10, startsExpr }),\n // unset `beforeExpr` as it can be `function *`\n star: createToken(\"*\", { binop: 10 }),\n slash: createBinop(\"/\", 10),\n exponent: createToken(\"**\", {\n beforeExpr,\n binop: 11,\n rightAssociative: true,\n }),\n\n // Keywords\n // Don't forget to update packages/babel-helper-validator-identifier/src/keyword.js\n // when new keywords are added\n // start: isLiteralPropertyName\n // start: isKeyword\n _in: createKeyword(\"in\", { beforeExpr, binop: 7 }),\n _instanceof: createKeyword(\"instanceof\", { beforeExpr, binop: 7 }),\n // end: isBinop\n _break: createKeyword(\"break\"),\n _case: createKeyword(\"case\", { beforeExpr }),\n _catch: createKeyword(\"catch\"),\n _continue: createKeyword(\"continue\"),\n _debugger: createKeyword(\"debugger\"),\n _default: createKeyword(\"default\", { beforeExpr }),\n _else: createKeyword(\"else\", { beforeExpr }),\n _finally: createKeyword(\"finally\"),\n _function: createKeyword(\"function\", { startsExpr }),\n _if: createKeyword(\"if\"),\n _return: createKeyword(\"return\", { beforeExpr }),\n _switch: createKeyword(\"switch\"),\n _throw: createKeyword(\"throw\", { beforeExpr, prefix, startsExpr }),\n _try: createKeyword(\"try\"),\n _var: createKeyword(\"var\"),\n _const: createKeyword(\"const\"),\n _with: createKeyword(\"with\"),\n _new: createKeyword(\"new\", { beforeExpr, startsExpr }),\n _this: createKeyword(\"this\", { startsExpr }),\n _super: createKeyword(\"super\", { startsExpr }),\n _class: createKeyword(\"class\", { startsExpr }),\n _extends: createKeyword(\"extends\", { beforeExpr }),\n _export: createKeyword(\"export\"),\n _import: createKeyword(\"import\", { startsExpr }),\n _null: createKeyword(\"null\", { startsExpr }),\n _true: createKeyword(\"true\", { startsExpr }),\n _false: createKeyword(\"false\", { startsExpr }),\n _typeof: createKeyword(\"typeof\", { beforeExpr, prefix, startsExpr }),\n _void: createKeyword(\"void\", { beforeExpr, prefix, startsExpr }),\n _delete: createKeyword(\"delete\", { beforeExpr, prefix, startsExpr }),\n // start: isLoop\n _do: createKeyword(\"do\", { isLoop, beforeExpr }),\n _for: createKeyword(\"for\", { isLoop }),\n _while: createKeyword(\"while\", { isLoop }),\n // end: isLoop\n // end: isKeyword\n\n // Primary literals\n // start: isIdentifier\n _as: createKeywordLike(\"as\", { startsExpr }),\n _assert: createKeywordLike(\"assert\", { startsExpr }),\n _async: createKeywordLike(\"async\", { startsExpr }),\n _await: createKeywordLike(\"await\", { startsExpr }),\n _from: createKeywordLike(\"from\", { startsExpr }),\n _get: createKeywordLike(\"get\", { startsExpr }),\n _let: createKeywordLike(\"let\", { startsExpr }),\n _meta: createKeywordLike(\"meta\", { startsExpr }),\n _of: createKeywordLike(\"of\", { startsExpr }),\n _sent: createKeywordLike(\"sent\", { startsExpr }),\n _set: createKeywordLike(\"set\", { startsExpr }),\n _static: createKeywordLike(\"static\", { startsExpr }),\n _yield: createKeywordLike(\"yield\", { startsExpr }),\n\n // Flow and TypeScript Keywordlike\n _asserts: createKeywordLike(\"asserts\", { startsExpr }),\n _checks: createKeywordLike(\"checks\", { startsExpr }),\n _exports: createKeywordLike(\"exports\", { startsExpr }),\n _global: createKeywordLike(\"global\", { startsExpr }),\n _implements: createKeywordLike(\"implements\", { startsExpr }),\n _intrinsic: createKeywordLike(\"intrinsic\", { startsExpr }),\n _infer: createKeywordLike(\"infer\", { startsExpr }),\n _is: createKeywordLike(\"is\", { startsExpr }),\n _mixins: createKeywordLike(\"mixins\", { startsExpr }),\n _proto: createKeywordLike(\"proto\", { startsExpr }),\n _require: createKeywordLike(\"require\", { startsExpr }),\n // start: isTSTypeOperator\n _keyof: createKeywordLike(\"keyof\", { startsExpr }),\n _readonly: createKeywordLike(\"readonly\", { startsExpr }),\n _unique: createKeywordLike(\"unique\", { startsExpr }),\n // end: isTSTypeOperator\n // start: isTSDeclarationStart\n _abstract: createKeywordLike(\"abstract\", { startsExpr }),\n _declare: createKeywordLike(\"declare\", { startsExpr }),\n _enum: createKeywordLike(\"enum\", { startsExpr }),\n _module: createKeywordLike(\"module\", { startsExpr }),\n _namespace: createKeywordLike(\"namespace\", { startsExpr }),\n // start: isFlowInterfaceOrTypeOrOpaque\n _interface: createKeywordLike(\"interface\", { startsExpr }),\n _type: createKeywordLike(\"type\", { startsExpr }),\n // end: isTSDeclarationStart\n _opaque: createKeywordLike(\"opaque\", { startsExpr }),\n // end: isFlowInterfaceOrTypeOrOpaque\n name: createToken(\"name\", { startsExpr }),\n // end: isIdentifier\n\n string: createToken(\"string\", { startsExpr }),\n num: createToken(\"num\", { startsExpr }),\n bigint: createToken(\"bigint\", { startsExpr }),\n decimal: createToken(\"decimal\", { startsExpr }),\n // end: isLiteralPropertyName\n regexp: createToken(\"regexp\", { startsExpr }),\n privateName: createToken(\"#name\", { startsExpr }),\n eof: createToken(\"eof\"),\n\n // jsx plugin\n jsxName: createToken(\"jsxName\"),\n jsxText: createToken(\"jsxText\", { beforeExpr: true }),\n jsxTagStart: createToken(\"jsxTagStart\", { startsExpr: true }),\n jsxTagEnd: createToken(\"jsxTagEnd\"),\n\n // placeholder plugin\n placeholder: createToken(\"%%\", { startsExpr: true }),\n};\n\nexport function tokenIsIdentifier(token: TokenType): boolean {\n return token >= tt._as && token <= tt.name;\n}\n\nexport function tokenKeywordOrIdentifierIsKeyword(token: TokenType): boolean {\n // we can remove the token >= tt._in check when we\n // know a token is either keyword or identifier\n return token <= tt._while;\n}\n\nexport function tokenIsKeywordOrIdentifier(token: TokenType): boolean {\n return token >= tt._in && token <= tt.name;\n}\n\nexport function tokenIsLiteralPropertyName(token: TokenType): boolean {\n return token >= tt._in && token <= tt.decimal;\n}\n\nexport function tokenComesBeforeExpression(token: TokenType): boolean {\n return tokenBeforeExprs[token];\n}\n\nexport function tokenCanStartExpression(token: TokenType): boolean {\n return tokenStartsExprs[token];\n}\n\nexport function tokenIsAssignment(token: TokenType): boolean {\n return token >= tt.eq && token <= tt.moduloAssign;\n}\n\nexport function tokenIsFlowInterfaceOrTypeOrOpaque(token: TokenType): boolean {\n return token >= tt._interface && token <= tt._opaque;\n}\n\nexport function tokenIsLoop(token: TokenType): boolean {\n return token >= tt._do && token <= tt._while;\n}\n\nexport function tokenIsKeyword(token: TokenType): boolean {\n return token >= tt._in && token <= tt._while;\n}\n\nexport function tokenIsOperator(token: TokenType): boolean {\n return token >= tt.pipeline && token <= tt._instanceof;\n}\n\nexport function tokenIsPostfix(token: TokenType): boolean {\n return token === tt.incDec;\n}\n\nexport function tokenIsPrefix(token: TokenType): boolean {\n return tokenPrefixes[token];\n}\n\nexport function tokenIsTSTypeOperator(token: TokenType): boolean {\n return token >= tt._keyof && token <= tt._unique;\n}\n\nexport function tokenIsTSDeclarationStart(token: TokenType): boolean {\n return token >= tt._abstract && token <= tt._type;\n}\n\nexport function tokenLabelName(token: TokenType): string {\n return tokenLabels[token];\n}\n\nexport function tokenOperatorPrecedence(token: TokenType): number {\n return tokenBinops[token];\n}\n\nexport function tokenIsRightAssociative(token: TokenType): boolean {\n return token === tt.exponent;\n}\n\nexport function tokenIsTemplate(token: TokenType): boolean {\n return token >= tt.templateTail && token <= tt.templateNonTail;\n}\n\nexport function getExportedToken(token: TokenType): ExportedTokenType {\n return tokenTypes[token];\n}\n\nexport function isTokenType(obj: any): boolean {\n return typeof obj === \"number\";\n}\n\nif (!process.env.BABEL_8_BREAKING) {\n tokenTypes[tt.braceR].updateContext = context => {\n context.pop();\n };\n\n tokenTypes[tt.braceL].updateContext =\n tokenTypes[tt.braceHashL].updateContext =\n tokenTypes[tt.dollarBraceL].updateContext =\n context => {\n context.push(tc.brace);\n };\n\n tokenTypes[tt.backQuote].updateContext = context => {\n if (context[context.length - 1] === tc.template) {\n context.pop();\n } else {\n context.push(tc.template);\n }\n };\n\n tokenTypes[tt.jsxTagStart].updateContext = context => {\n context.push(tc.j_expr, tc.j_oTag);\n };\n}\n","// @flow\n\nexport type Pos = {\n start: number,\n};\n\n// These are used when `options.locations` is on, for the\n// `startLoc` and `endLoc` properties.\n\nexport class Position {\n line: number;\n column: number;\n index: number;\n\n constructor(line: number, col: number, index: number) {\n this.line = line;\n this.column = col;\n this.index = index;\n }\n}\n\nexport class SourceLocation {\n start: Position;\n end: Position;\n filename: string;\n identifierName: ?string;\n\n constructor(start: Position, end?: Position) {\n this.start = start;\n // $FlowIgnore (may start as null, but initialized later)\n this.end = end;\n }\n}\n\n/**\n * creates a new position with a non-zero column offset from the given position.\n * This function should be only be used when we create AST node out of the token\n * boundaries, such as TemplateElement ends before tt.templateNonTail. This\n * function does not skip whitespaces.\n *\n * @export\n * @param {Position} position\n * @param {number} columnOffset\n * @returns {Position}\n */\nexport function createPositionWithColumnOffset(\n position: Position,\n columnOffset: number,\n) {\n const { line, column, index } = position;\n return new Position(line, column + columnOffset, index + columnOffset);\n}\n","import * as charCodes from \"charcodes\";\n\n// ## Character categories\n\n// Big ugly regular expressions that match characters in the\n// whitespace, identifier, and identifier-start categories. These\n// are only applied when a character is found to actually have a\n// code point between 0x80 and 0xffff.\n// Generated by `scripts/generate-identifier-regex.js`.\n\n/* prettier-ignore */\nlet nonASCIIidentifierStartChars = \"\\xaa\\xb5\\xba\\xc0-\\xd6\\xd8-\\xf6\\xf8-\\u02c1\\u02c6-\\u02d1\\u02e0-\\u02e4\\u02ec\\u02ee\\u0370-\\u0374\\u0376\\u0377\\u037a-\\u037d\\u037f\\u0386\\u0388-\\u038a\\u038c\\u038e-\\u03a1\\u03a3-\\u03f5\\u03f7-\\u0481\\u048a-\\u052f\\u0531-\\u0556\\u0559\\u0560-\\u0588\\u05d0-\\u05ea\\u05ef-\\u05f2\\u0620-\\u064a\\u066e\\u066f\\u0671-\\u06d3\\u06d5\\u06e5\\u06e6\\u06ee\\u06ef\\u06fa-\\u06fc\\u06ff\\u0710\\u0712-\\u072f\\u074d-\\u07a5\\u07b1\\u07ca-\\u07ea\\u07f4\\u07f5\\u07fa\\u0800-\\u0815\\u081a\\u0824\\u0828\\u0840-\\u0858\\u0860-\\u086a\\u0870-\\u0887\\u0889-\\u088e\\u08a0-\\u08c9\\u0904-\\u0939\\u093d\\u0950\\u0958-\\u0961\\u0971-\\u0980\\u0985-\\u098c\\u098f\\u0990\\u0993-\\u09a8\\u09aa-\\u09b0\\u09b2\\u09b6-\\u09b9\\u09bd\\u09ce\\u09dc\\u09dd\\u09df-\\u09e1\\u09f0\\u09f1\\u09fc\\u0a05-\\u0a0a\\u0a0f\\u0a10\\u0a13-\\u0a28\\u0a2a-\\u0a30\\u0a32\\u0a33\\u0a35\\u0a36\\u0a38\\u0a39\\u0a59-\\u0a5c\\u0a5e\\u0a72-\\u0a74\\u0a85-\\u0a8d\\u0a8f-\\u0a91\\u0a93-\\u0aa8\\u0aaa-\\u0ab0\\u0ab2\\u0ab3\\u0ab5-\\u0ab9\\u0abd\\u0ad0\\u0ae0\\u0ae1\\u0af9\\u0b05-\\u0b0c\\u0b0f\\u0b10\\u0b13-\\u0b28\\u0b2a-\\u0b30\\u0b32\\u0b33\\u0b35-\\u0b39\\u0b3d\\u0b5c\\u0b5d\\u0b5f-\\u0b61\\u0b71\\u0b83\\u0b85-\\u0b8a\\u0b8e-\\u0b90\\u0b92-\\u0b95\\u0b99\\u0b9a\\u0b9c\\u0b9e\\u0b9f\\u0ba3\\u0ba4\\u0ba8-\\u0baa\\u0bae-\\u0bb9\\u0bd0\\u0c05-\\u0c0c\\u0c0e-\\u0c10\\u0c12-\\u0c28\\u0c2a-\\u0c39\\u0c3d\\u0c58-\\u0c5a\\u0c5d\\u0c60\\u0c61\\u0c80\\u0c85-\\u0c8c\\u0c8e-\\u0c90\\u0c92-\\u0ca8\\u0caa-\\u0cb3\\u0cb5-\\u0cb9\\u0cbd\\u0cdd\\u0cde\\u0ce0\\u0ce1\\u0cf1\\u0cf2\\u0d04-\\u0d0c\\u0d0e-\\u0d10\\u0d12-\\u0d3a\\u0d3d\\u0d4e\\u0d54-\\u0d56\\u0d5f-\\u0d61\\u0d7a-\\u0d7f\\u0d85-\\u0d96\\u0d9a-\\u0db1\\u0db3-\\u0dbb\\u0dbd\\u0dc0-\\u0dc6\\u0e01-\\u0e30\\u0e32\\u0e33\\u0e40-\\u0e46\\u0e81\\u0e82\\u0e84\\u0e86-\\u0e8a\\u0e8c-\\u0ea3\\u0ea5\\u0ea7-\\u0eb0\\u0eb2\\u0eb3\\u0ebd\\u0ec0-\\u0ec4\\u0ec6\\u0edc-\\u0edf\\u0f00\\u0f40-\\u0f47\\u0f49-\\u0f6c\\u0f88-\\u0f8c\\u1000-\\u102a\\u103f\\u1050-\\u1055\\u105a-\\u105d\\u1061\\u1065\\u1066\\u106e-\\u1070\\u1075-\\u1081\\u108e\\u10a0-\\u10c5\\u10c7\\u10cd\\u10d0-\\u10fa\\u10fc-\\u1248\\u124a-\\u124d\\u1250-\\u1256\\u1258\\u125a-\\u125d\\u1260-\\u1288\\u128a-\\u128d\\u1290-\\u12b0\\u12b2-\\u12b5\\u12b8-\\u12be\\u12c0\\u12c2-\\u12c5\\u12c8-\\u12d6\\u12d8-\\u1310\\u1312-\\u1315\\u1318-\\u135a\\u1380-\\u138f\\u13a0-\\u13f5\\u13f8-\\u13fd\\u1401-\\u166c\\u166f-\\u167f\\u1681-\\u169a\\u16a0-\\u16ea\\u16ee-\\u16f8\\u1700-\\u1711\\u171f-\\u1731\\u1740-\\u1751\\u1760-\\u176c\\u176e-\\u1770\\u1780-\\u17b3\\u17d7\\u17dc\\u1820-\\u1878\\u1880-\\u18a8\\u18aa\\u18b0-\\u18f5\\u1900-\\u191e\\u1950-\\u196d\\u1970-\\u1974\\u1980-\\u19ab\\u19b0-\\u19c9\\u1a00-\\u1a16\\u1a20-\\u1a54\\u1aa7\\u1b05-\\u1b33\\u1b45-\\u1b4c\\u1b83-\\u1ba0\\u1bae\\u1baf\\u1bba-\\u1be5\\u1c00-\\u1c23\\u1c4d-\\u1c4f\\u1c5a-\\u1c7d\\u1c80-\\u1c88\\u1c90-\\u1cba\\u1cbd-\\u1cbf\\u1ce9-\\u1cec\\u1cee-\\u1cf3\\u1cf5\\u1cf6\\u1cfa\\u1d00-\\u1dbf\\u1e00-\\u1f15\\u1f18-\\u1f1d\\u1f20-\\u1f45\\u1f48-\\u1f4d\\u1f50-\\u1f57\\u1f59\\u1f5b\\u1f5d\\u1f5f-\\u1f7d\\u1f80-\\u1fb4\\u1fb6-\\u1fbc\\u1fbe\\u1fc2-\\u1fc4\\u1fc6-\\u1fcc\\u1fd0-\\u1fd3\\u1fd6-\\u1fdb\\u1fe0-\\u1fec\\u1ff2-\\u1ff4\\u1ff6-\\u1ffc\\u2071\\u207f\\u2090-\\u209c\\u2102\\u2107\\u210a-\\u2113\\u2115\\u2118-\\u211d\\u2124\\u2126\\u2128\\u212a-\\u2139\\u213c-\\u213f\\u2145-\\u2149\\u214e\\u2160-\\u2188\\u2c00-\\u2ce4\\u2ceb-\\u2cee\\u2cf2\\u2cf3\\u2d00-\\u2d25\\u2d27\\u2d2d\\u2d30-\\u2d67\\u2d6f\\u2d80-\\u2d96\\u2da0-\\u2da6\\u2da8-\\u2dae\\u2db0-\\u2db6\\u2db8-\\u2dbe\\u2dc0-\\u2dc6\\u2dc8-\\u2dce\\u2dd0-\\u2dd6\\u2dd8-\\u2dde\\u3005-\\u3007\\u3021-\\u3029\\u3031-\\u3035\\u3038-\\u303c\\u3041-\\u3096\\u309b-\\u309f\\u30a1-\\u30fa\\u30fc-\\u30ff\\u3105-\\u312f\\u3131-\\u318e\\u31a0-\\u31bf\\u31f0-\\u31ff\\u3400-\\u4dbf\\u4e00-\\ua48c\\ua4d0-\\ua4fd\\ua500-\\ua60c\\ua610-\\ua61f\\ua62a\\ua62b\\ua640-\\ua66e\\ua67f-\\ua69d\\ua6a0-\\ua6ef\\ua717-\\ua71f\\ua722-\\ua788\\ua78b-\\ua7ca\\ua7d0\\ua7d1\\ua7d3\\ua7d5-\\ua7d9\\ua7f2-\\ua801\\ua803-\\ua805\\ua807-\\ua80a\\ua80c-\\ua822\\ua840-\\ua873\\ua882-\\ua8b3\\ua8f2-\\ua8f7\\ua8fb\\ua8fd\\ua8fe\\ua90a-\\ua925\\ua930-\\ua946\\ua960-\\ua97c\\ua984-\\ua9b2\\ua9cf\\ua9e0-\\ua9e4\\ua9e6-\\ua9ef\\ua9fa-\\ua9fe\\uaa00-\\uaa28\\uaa40-\\uaa42\\uaa44-\\uaa4b\\uaa60-\\uaa76\\uaa7a\\uaa7e-\\uaaaf\\uaab1\\uaab5\\uaab6\\uaab9-\\uaabd\\uaac0\\uaac2\\uaadb-\\uaadd\\uaae0-\\uaaea\\uaaf2-\\uaaf4\\uab01-\\uab06\\uab09-\\uab0e\\uab11-\\uab16\\uab20-\\uab26\\uab28-\\uab2e\\uab30-\\uab5a\\uab5c-\\uab69\\uab70-\\uabe2\\uac00-\\ud7a3\\ud7b0-\\ud7c6\\ud7cb-\\ud7fb\\uf900-\\ufa6d\\ufa70-\\ufad9\\ufb00-\\ufb06\\ufb13-\\ufb17\\ufb1d\\ufb1f-\\ufb28\\ufb2a-\\ufb36\\ufb38-\\ufb3c\\ufb3e\\ufb40\\ufb41\\ufb43\\ufb44\\ufb46-\\ufbb1\\ufbd3-\\ufd3d\\ufd50-\\ufd8f\\ufd92-\\ufdc7\\ufdf0-\\ufdfb\\ufe70-\\ufe74\\ufe76-\\ufefc\\uff21-\\uff3a\\uff41-\\uff5a\\uff66-\\uffbe\\uffc2-\\uffc7\\uffca-\\uffcf\\uffd2-\\uffd7\\uffda-\\uffdc\";\n/* prettier-ignore */\nlet nonASCIIidentifierChars = \"\\u200c\\u200d\\xb7\\u0300-\\u036f\\u0387\\u0483-\\u0487\\u0591-\\u05bd\\u05bf\\u05c1\\u05c2\\u05c4\\u05c5\\u05c7\\u0610-\\u061a\\u064b-\\u0669\\u0670\\u06d6-\\u06dc\\u06df-\\u06e4\\u06e7\\u06e8\\u06ea-\\u06ed\\u06f0-\\u06f9\\u0711\\u0730-\\u074a\\u07a6-\\u07b0\\u07c0-\\u07c9\\u07eb-\\u07f3\\u07fd\\u0816-\\u0819\\u081b-\\u0823\\u0825-\\u0827\\u0829-\\u082d\\u0859-\\u085b\\u0898-\\u089f\\u08ca-\\u08e1\\u08e3-\\u0903\\u093a-\\u093c\\u093e-\\u094f\\u0951-\\u0957\\u0962\\u0963\\u0966-\\u096f\\u0981-\\u0983\\u09bc\\u09be-\\u09c4\\u09c7\\u09c8\\u09cb-\\u09cd\\u09d7\\u09e2\\u09e3\\u09e6-\\u09ef\\u09fe\\u0a01-\\u0a03\\u0a3c\\u0a3e-\\u0a42\\u0a47\\u0a48\\u0a4b-\\u0a4d\\u0a51\\u0a66-\\u0a71\\u0a75\\u0a81-\\u0a83\\u0abc\\u0abe-\\u0ac5\\u0ac7-\\u0ac9\\u0acb-\\u0acd\\u0ae2\\u0ae3\\u0ae6-\\u0aef\\u0afa-\\u0aff\\u0b01-\\u0b03\\u0b3c\\u0b3e-\\u0b44\\u0b47\\u0b48\\u0b4b-\\u0b4d\\u0b55-\\u0b57\\u0b62\\u0b63\\u0b66-\\u0b6f\\u0b82\\u0bbe-\\u0bc2\\u0bc6-\\u0bc8\\u0bca-\\u0bcd\\u0bd7\\u0be6-\\u0bef\\u0c00-\\u0c04\\u0c3c\\u0c3e-\\u0c44\\u0c46-\\u0c48\\u0c4a-\\u0c4d\\u0c55\\u0c56\\u0c62\\u0c63\\u0c66-\\u0c6f\\u0c81-\\u0c83\\u0cbc\\u0cbe-\\u0cc4\\u0cc6-\\u0cc8\\u0cca-\\u0ccd\\u0cd5\\u0cd6\\u0ce2\\u0ce3\\u0ce6-\\u0cef\\u0d00-\\u0d03\\u0d3b\\u0d3c\\u0d3e-\\u0d44\\u0d46-\\u0d48\\u0d4a-\\u0d4d\\u0d57\\u0d62\\u0d63\\u0d66-\\u0d6f\\u0d81-\\u0d83\\u0dca\\u0dcf-\\u0dd4\\u0dd6\\u0dd8-\\u0ddf\\u0de6-\\u0def\\u0df2\\u0df3\\u0e31\\u0e34-\\u0e3a\\u0e47-\\u0e4e\\u0e50-\\u0e59\\u0eb1\\u0eb4-\\u0ebc\\u0ec8-\\u0ecd\\u0ed0-\\u0ed9\\u0f18\\u0f19\\u0f20-\\u0f29\\u0f35\\u0f37\\u0f39\\u0f3e\\u0f3f\\u0f71-\\u0f84\\u0f86\\u0f87\\u0f8d-\\u0f97\\u0f99-\\u0fbc\\u0fc6\\u102b-\\u103e\\u1040-\\u1049\\u1056-\\u1059\\u105e-\\u1060\\u1062-\\u1064\\u1067-\\u106d\\u1071-\\u1074\\u1082-\\u108d\\u108f-\\u109d\\u135d-\\u135f\\u1369-\\u1371\\u1712-\\u1715\\u1732-\\u1734\\u1752\\u1753\\u1772\\u1773\\u17b4-\\u17d3\\u17dd\\u17e0-\\u17e9\\u180b-\\u180d\\u180f-\\u1819\\u18a9\\u1920-\\u192b\\u1930-\\u193b\\u1946-\\u194f\\u19d0-\\u19da\\u1a17-\\u1a1b\\u1a55-\\u1a5e\\u1a60-\\u1a7c\\u1a7f-\\u1a89\\u1a90-\\u1a99\\u1ab0-\\u1abd\\u1abf-\\u1ace\\u1b00-\\u1b04\\u1b34-\\u1b44\\u1b50-\\u1b59\\u1b6b-\\u1b73\\u1b80-\\u1b82\\u1ba1-\\u1bad\\u1bb0-\\u1bb9\\u1be6-\\u1bf3\\u1c24-\\u1c37\\u1c40-\\u1c49\\u1c50-\\u1c59\\u1cd0-\\u1cd2\\u1cd4-\\u1ce8\\u1ced\\u1cf4\\u1cf7-\\u1cf9\\u1dc0-\\u1dff\\u203f\\u2040\\u2054\\u20d0-\\u20dc\\u20e1\\u20e5-\\u20f0\\u2cef-\\u2cf1\\u2d7f\\u2de0-\\u2dff\\u302a-\\u302f\\u3099\\u309a\\ua620-\\ua629\\ua66f\\ua674-\\ua67d\\ua69e\\ua69f\\ua6f0\\ua6f1\\ua802\\ua806\\ua80b\\ua823-\\ua827\\ua82c\\ua880\\ua881\\ua8b4-\\ua8c5\\ua8d0-\\ua8d9\\ua8e0-\\ua8f1\\ua8ff-\\ua909\\ua926-\\ua92d\\ua947-\\ua953\\ua980-\\ua983\\ua9b3-\\ua9c0\\ua9d0-\\ua9d9\\ua9e5\\ua9f0-\\ua9f9\\uaa29-\\uaa36\\uaa43\\uaa4c\\uaa4d\\uaa50-\\uaa59\\uaa7b-\\uaa7d\\uaab0\\uaab2-\\uaab4\\uaab7\\uaab8\\uaabe\\uaabf\\uaac1\\uaaeb-\\uaaef\\uaaf5\\uaaf6\\uabe3-\\uabea\\uabec\\uabed\\uabf0-\\uabf9\\ufb1e\\ufe00-\\ufe0f\\ufe20-\\ufe2f\\ufe33\\ufe34\\ufe4d-\\ufe4f\\uff10-\\uff19\\uff3f\";\n\nconst nonASCIIidentifierStart = new RegExp(\n \"[\" + nonASCIIidentifierStartChars + \"]\",\n);\nconst nonASCIIidentifier = new RegExp(\n \"[\" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + \"]\",\n);\n\nnonASCIIidentifierStartChars = nonASCIIidentifierChars = null;\n\n// These are a run-length and offset-encoded representation of the\n// >0xffff code points that are a valid part of identifiers. The\n// offset starts at 0x10000, and each pair of numbers represents an\n// offset to the next range, and then a size of the range. They were\n// generated by `scripts/generate-identifier-regex.js`.\n/* prettier-ignore */\nconst astralIdentifierStartCodes = [0,11,2,25,2,18,2,1,2,14,3,13,35,122,70,52,268,28,4,48,48,31,14,29,6,37,11,29,3,35,5,7,2,4,43,157,19,35,5,35,5,39,9,51,13,10,2,14,2,6,2,1,2,10,2,14,2,6,2,1,68,310,10,21,11,7,25,5,2,41,2,8,70,5,3,0,2,43,2,1,4,0,3,22,11,22,10,30,66,18,2,1,11,21,11,25,71,55,7,1,65,0,16,3,2,2,2,28,43,28,4,28,36,7,2,27,28,53,11,21,11,18,14,17,111,72,56,50,14,50,14,35,349,41,7,1,79,28,11,0,9,21,43,17,47,20,28,22,13,52,58,1,3,0,14,44,33,24,27,35,30,0,3,0,9,34,4,0,13,47,15,3,22,0,2,0,36,17,2,24,85,6,2,0,2,3,2,14,2,9,8,46,39,7,3,1,3,21,2,6,2,1,2,4,4,0,19,0,13,4,159,52,19,3,21,2,31,47,21,1,2,0,185,46,42,3,37,47,21,0,60,42,14,0,72,26,38,6,186,43,117,63,32,7,3,0,3,7,2,1,2,23,16,0,2,0,95,7,3,38,17,0,2,0,29,0,11,39,8,0,22,0,12,45,20,0,19,72,264,8,2,36,18,0,50,29,113,6,2,1,2,37,22,0,26,5,2,1,2,31,15,0,328,18,190,0,80,921,103,110,18,195,2637,96,16,1070,4050,582,8634,568,8,30,18,78,18,29,19,47,17,3,32,20,6,18,689,63,129,74,6,0,67,12,65,1,2,0,29,6135,9,1237,43,8,8936,3,2,6,2,1,2,290,46,2,18,3,9,395,2309,106,6,12,4,8,8,9,5991,84,2,70,2,1,3,0,3,1,3,3,2,11,2,0,2,6,2,64,2,3,3,7,2,6,2,27,2,3,2,4,2,0,4,6,2,339,3,24,2,24,2,30,2,24,2,30,2,24,2,30,2,24,2,30,2,24,2,7,1845,30,482,44,11,6,17,0,322,29,19,43,1269,6,2,3,2,1,2,14,2,196,60,67,8,0,1205,3,2,26,2,1,2,0,3,0,2,9,2,3,2,0,2,0,7,0,5,0,2,0,2,0,2,2,2,1,2,0,3,0,2,0,2,0,2,0,2,0,2,1,2,0,3,3,2,6,2,3,2,3,2,0,2,9,2,16,6,2,2,4,2,16,4421,42719,33,4152,8,221,3,5761,15,7472,3104,541,1507,4938];\n/* prettier-ignore */\nconst astralIdentifierCodes = [509,0,227,0,150,4,294,9,1368,2,2,1,6,3,41,2,5,0,166,1,574,3,9,9,370,1,154,10,50,3,123,2,54,14,32,10,3,1,11,3,46,10,8,0,46,9,7,2,37,13,2,9,6,1,45,0,13,2,49,13,9,3,2,11,83,11,7,0,161,11,6,9,7,3,56,1,2,6,3,1,3,2,10,0,11,1,3,6,4,4,193,17,10,9,5,0,82,19,13,9,214,6,3,8,28,1,83,16,16,9,82,12,9,9,84,14,5,9,243,14,166,9,71,5,2,1,3,3,2,0,2,1,13,9,120,6,3,6,4,0,29,9,41,6,2,3,9,0,10,10,47,15,406,7,2,7,17,9,57,21,2,13,123,5,4,0,2,1,2,6,2,0,9,9,49,4,2,1,2,4,9,9,330,3,19306,9,87,9,39,4,60,6,26,9,1014,0,2,54,8,3,82,0,12,1,19628,1,4706,45,3,22,543,4,4,5,9,7,3,6,31,3,149,2,1418,49,513,54,5,49,9,0,15,0,23,4,2,14,1361,6,2,16,3,6,2,1,2,4,262,6,10,9,357,0,62,13,1495,6,110,6,6,9,4759,9,787719,239];\n\n// This has a complexity linear to the value of the code. The\n// assumption is that looking up astral identifier characters is\n// rare.\nfunction isInAstralSet(code: number, set: readonly number[]): boolean {\n let pos = 0x10000;\n for (let i = 0, length = set.length; i < length; i += 2) {\n pos += set[i];\n if (pos > code) return false;\n\n pos += set[i + 1];\n if (pos >= code) return true;\n }\n return false;\n}\n\n// Test whether a given character code starts an identifier.\n\nexport function isIdentifierStart(code: number): boolean {\n if (code < charCodes.uppercaseA) return code === charCodes.dollarSign;\n if (code <= charCodes.uppercaseZ) return true;\n if (code < charCodes.lowercaseA) return code === charCodes.underscore;\n if (code <= charCodes.lowercaseZ) return true;\n if (code <= 0xffff) {\n return (\n code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code))\n );\n }\n return isInAstralSet(code, astralIdentifierStartCodes);\n}\n\n// Test whether a given character is part of an identifier.\n\nexport function isIdentifierChar(code: number): boolean {\n if (code < charCodes.digit0) return code === charCodes.dollarSign;\n if (code < charCodes.colon) return true;\n if (code < charCodes.uppercaseA) return false;\n if (code <= charCodes.uppercaseZ) return true;\n if (code < charCodes.lowercaseA) return code === charCodes.underscore;\n if (code <= charCodes.lowercaseZ) return true;\n if (code <= 0xffff) {\n return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));\n }\n return (\n isInAstralSet(code, astralIdentifierStartCodes) ||\n isInAstralSet(code, astralIdentifierCodes)\n );\n}\n\n// Test whether a given string is a valid identifier name\n\nexport function isIdentifierName(name: string): boolean {\n let isFirst = true;\n for (let i = 0; i < name.length; i++) {\n // The implementation is based on\n // https://source.chromium.org/chromium/chromium/src/+/master:v8/src/builtins/builtins-string-gen.cc;l=1455;drc=221e331b49dfefadbc6fa40b0c68e6f97606d0b3;bpv=0;bpt=1\n // We reimplement `codePointAt` because `codePointAt` is a V8 builtin which is not inlined by TurboFan (as of M91)\n // since `name` is mostly ASCII, an inlined `charCodeAt` wins here\n let cp = name.charCodeAt(i);\n if ((cp & 0xfc00) === 0xd800 && i + 1 < name.length) {\n const trail = name.charCodeAt(++i);\n if ((trail & 0xfc00) === 0xdc00) {\n cp = 0x10000 + ((cp & 0x3ff) << 10) + (trail & 0x3ff);\n }\n }\n if (isFirst) {\n isFirst = false;\n if (!isIdentifierStart(cp)) {\n return false;\n }\n } else if (!isIdentifierChar(cp)) {\n return false;\n }\n }\n return !isFirst;\n}\n","const reservedWords = {\n keyword: [\n \"break\",\n \"case\",\n \"catch\",\n \"continue\",\n \"debugger\",\n \"default\",\n \"do\",\n \"else\",\n \"finally\",\n \"for\",\n \"function\",\n \"if\",\n \"return\",\n \"switch\",\n \"throw\",\n \"try\",\n \"var\",\n \"const\",\n \"while\",\n \"with\",\n \"new\",\n \"this\",\n \"super\",\n \"class\",\n \"extends\",\n \"export\",\n \"import\",\n \"null\",\n \"true\",\n \"false\",\n \"in\",\n \"instanceof\",\n \"typeof\",\n \"void\",\n \"delete\",\n ],\n strict: [\n \"implements\",\n \"interface\",\n \"let\",\n \"package\",\n \"private\",\n \"protected\",\n \"public\",\n \"static\",\n \"yield\",\n ],\n strictBind: [\"eval\", \"arguments\"],\n};\nconst keywords = new Set(reservedWords.keyword);\nconst reservedWordsStrictSet = new Set(reservedWords.strict);\nconst reservedWordsStrictBindSet = new Set(reservedWords.strictBind);\n\n/**\n * Checks if word is a reserved word in non-strict mode\n */\nexport function isReservedWord(word: string, inModule: boolean): boolean {\n return (inModule && word === \"await\") || word === \"enum\";\n}\n\n/**\n * Checks if word is a reserved word in non-binding strict mode\n *\n * Includes non-strict reserved words\n */\nexport function isStrictReservedWord(word: string, inModule: boolean): boolean {\n return isReservedWord(word, inModule) || reservedWordsStrictSet.has(word);\n}\n\n/**\n * Checks if word is a reserved word in binding strict mode, but it is allowed as\n * a normal identifier.\n */\nexport function isStrictBindOnlyReservedWord(word: string): boolean {\n return reservedWordsStrictBindSet.has(word);\n}\n\n/**\n * Checks if word is a reserved word in binding strict mode\n *\n * Includes non-strict reserved words and non-binding strict reserved words\n */\nexport function isStrictBindReservedWord(\n word: string,\n inModule: boolean,\n): boolean {\n return (\n isStrictReservedWord(word, inModule) || isStrictBindOnlyReservedWord(word)\n );\n}\n\nexport function isKeyword(word: string): boolean {\n return keywords.has(word);\n}\n","/* eslint max-len: 0 */\n\n// @flow\n\nimport * as charCodes from \"charcodes\";\nimport { isIdentifierStart } from \"@babel/helper-validator-identifier\";\n\nexport {\n isIdentifierStart,\n isIdentifierChar,\n isReservedWord,\n isStrictBindOnlyReservedWord,\n isStrictBindReservedWord,\n isStrictReservedWord,\n isKeyword,\n} from \"@babel/helper-validator-identifier\";\n\nexport const keywordRelationalOperator = /^in(stanceof)?$/;\n\n// Test whether a current state character code and next character code is @\n\nexport function isIteratorStart(\n current: number,\n next: number,\n next2: number,\n): boolean {\n return (\n current === charCodes.atSign &&\n next === charCodes.atSign &&\n isIdentifierStart(next2)\n );\n}\n\n// This is the comprehensive set of JavaScript reserved words\n// If a word is in this set, it could be a reserved word,\n// depending on sourceType/strictMode/binding info. In other words\n// if a word is not in this set, it is not a reserved word under\n// any circumstance.\nconst reservedWordLikeSet = new Set([\n \"break\",\n \"case\",\n \"catch\",\n \"continue\",\n \"debugger\",\n \"default\",\n \"do\",\n \"else\",\n \"finally\",\n \"for\",\n \"function\",\n \"if\",\n \"return\",\n \"switch\",\n \"throw\",\n \"try\",\n \"var\",\n \"const\",\n \"while\",\n \"with\",\n \"new\",\n \"this\",\n \"super\",\n \"class\",\n \"extends\",\n \"export\",\n \"import\",\n \"null\",\n \"true\",\n \"false\",\n \"in\",\n \"instanceof\",\n \"typeof\",\n \"void\",\n \"delete\",\n // strict\n \"implements\",\n \"interface\",\n \"let\",\n \"package\",\n \"private\",\n \"protected\",\n \"public\",\n \"static\",\n \"yield\",\n // strictBind\n \"eval\",\n \"arguments\",\n // reservedWorkLike\n \"enum\",\n \"await\",\n]);\n\nexport function canBeReservedWord(word: string): boolean {\n return reservedWordLikeSet.has(word);\n}\n","// @flow\n\n// Each scope gets a bitset that may contain these flags\n// prettier-ignore\nexport const SCOPE_OTHER = 0b000000000,\n SCOPE_PROGRAM = 0b000000001,\n SCOPE_FUNCTION = 0b000000010,\n SCOPE_ARROW = 0b000000100,\n SCOPE_SIMPLE_CATCH = 0b000001000,\n SCOPE_SUPER = 0b000010000,\n SCOPE_DIRECT_SUPER = 0b000100000,\n SCOPE_CLASS = 0b001000000,\n SCOPE_STATIC_BLOCK = 0b010000000,\n SCOPE_TS_MODULE = 0b100000000,\n SCOPE_VAR = SCOPE_PROGRAM | SCOPE_FUNCTION | SCOPE_TS_MODULE;\n\nexport type ScopeFlags =\n | typeof SCOPE_OTHER\n | typeof SCOPE_PROGRAM\n | typeof SCOPE_FUNCTION\n | typeof SCOPE_VAR\n | typeof SCOPE_ARROW\n | typeof SCOPE_SIMPLE_CATCH\n | typeof SCOPE_SUPER\n | typeof SCOPE_DIRECT_SUPER\n | typeof SCOPE_CLASS\n | typeof SCOPE_STATIC_BLOCK;\n\n// These flags are meant to be _only_ used inside the Scope class (or subclasses).\n// prettier-ignore\nexport const BIND_KIND_VALUE = 0b000000_0000_01,\n BIND_KIND_TYPE = 0b000000_0000_10,\n // Used in checkLVal and declareName to determine the type of a binding\n BIND_SCOPE_VAR = 0b000000_0001_00, // Var-style binding\n BIND_SCOPE_LEXICAL = 0b000000_0010_00, // Let- or const-style binding\n BIND_SCOPE_FUNCTION = 0b000000_0100_00, // Function declaration\n BIND_SCOPE_OUTSIDE = 0b000000_1000_00, // Special case for function names as\n // bound inside the function\n // Misc flags\n BIND_FLAGS_NONE = 0b000001_0000_00,\n BIND_FLAGS_CLASS = 0b000010_0000_00,\n BIND_FLAGS_TS_ENUM = 0b000100_0000_00,\n BIND_FLAGS_TS_CONST_ENUM = 0b001000_0000_00,\n BIND_FLAGS_TS_EXPORT_ONLY = 0b010000_0000_00,\n BIND_FLAGS_FLOW_DECLARE_FN = 0b100000_0000_00;\n\n// These flags are meant to be _only_ used by Scope consumers\n// prettier-ignore\n/* = is value? | is type? | scope | misc flags */\nexport const BIND_CLASS = BIND_KIND_VALUE | BIND_KIND_TYPE | BIND_SCOPE_LEXICAL | BIND_FLAGS_CLASS ,\n BIND_LEXICAL = BIND_KIND_VALUE | 0 | BIND_SCOPE_LEXICAL | 0 ,\n BIND_VAR = BIND_KIND_VALUE | 0 | BIND_SCOPE_VAR | 0 ,\n BIND_FUNCTION = BIND_KIND_VALUE | 0 | BIND_SCOPE_FUNCTION | 0 ,\n BIND_TS_INTERFACE = 0 | BIND_KIND_TYPE | 0 | BIND_FLAGS_CLASS ,\n BIND_TS_TYPE = 0 | BIND_KIND_TYPE | 0 | 0 ,\n BIND_TS_ENUM = BIND_KIND_VALUE | BIND_KIND_TYPE | BIND_SCOPE_LEXICAL | BIND_FLAGS_TS_ENUM,\n BIND_TS_AMBIENT = 0 | 0 | 0 | BIND_FLAGS_TS_EXPORT_ONLY,\n // These bindings don't introduce anything in the scope. They are used for assignments and\n // function expressions IDs.\n BIND_NONE = 0 | 0 | 0 | BIND_FLAGS_NONE ,\n BIND_OUTSIDE = BIND_KIND_VALUE | 0 | 0 | BIND_FLAGS_NONE ,\n\n BIND_TS_CONST_ENUM = BIND_TS_ENUM | BIND_FLAGS_TS_CONST_ENUM,\n BIND_TS_NAMESPACE = 0 | 0 | 0 | BIND_FLAGS_TS_EXPORT_ONLY,\n\n BIND_FLOW_DECLARE_FN = BIND_FLAGS_FLOW_DECLARE_FN;\n\nexport type BindingTypes =\n | typeof BIND_NONE\n | typeof BIND_OUTSIDE\n | typeof BIND_VAR\n | typeof BIND_LEXICAL\n | typeof BIND_CLASS\n | typeof BIND_FUNCTION\n | typeof BIND_TS_INTERFACE\n | typeof BIND_TS_TYPE\n | typeof BIND_TS_ENUM\n | typeof BIND_TS_AMBIENT\n | typeof BIND_TS_NAMESPACE;\n\n// prettier-ignore\nexport const CLASS_ELEMENT_FLAG_STATIC = 0b1_00,\n CLASS_ELEMENT_KIND_GETTER = 0b0_10,\n CLASS_ELEMENT_KIND_SETTER = 0b0_01,\n CLASS_ELEMENT_KIND_ACCESSOR = CLASS_ELEMENT_KIND_GETTER | CLASS_ELEMENT_KIND_SETTER;\n\n// prettier-ignore\nexport const CLASS_ELEMENT_STATIC_GETTER = CLASS_ELEMENT_KIND_GETTER | CLASS_ELEMENT_FLAG_STATIC,\n CLASS_ELEMENT_STATIC_SETTER = CLASS_ELEMENT_KIND_SETTER | CLASS_ELEMENT_FLAG_STATIC,\n CLASS_ELEMENT_INSTANCE_GETTER = CLASS_ELEMENT_KIND_GETTER,\n CLASS_ELEMENT_INSTANCE_SETTER = CLASS_ELEMENT_KIND_SETTER,\n CLASS_ELEMENT_OTHER = 0;\n\nexport type ClassElementTypes =\n | typeof CLASS_ELEMENT_STATIC_GETTER\n | typeof CLASS_ELEMENT_STATIC_SETTER\n | typeof CLASS_ELEMENT_INSTANCE_GETTER\n | typeof CLASS_ELEMENT_INSTANCE_SETTER\n | typeof CLASS_ELEMENT_OTHER;\n","// @flow\nimport {\n SCOPE_ARROW,\n SCOPE_DIRECT_SUPER,\n SCOPE_FUNCTION,\n SCOPE_SIMPLE_CATCH,\n SCOPE_SUPER,\n SCOPE_PROGRAM,\n SCOPE_VAR,\n SCOPE_CLASS,\n SCOPE_STATIC_BLOCK,\n BIND_SCOPE_FUNCTION,\n BIND_SCOPE_VAR,\n BIND_SCOPE_LEXICAL,\n BIND_KIND_VALUE,\n type ScopeFlags,\n type BindingTypes,\n} from \"./scopeflags\";\nimport { Position } from \"./location\";\nimport * as N from \"../types\";\nimport { Errors, type raiseFunction } from \"../parser/error\";\n\n// Start an AST node, attaching a start offset.\nexport class Scope {\n declare flags: ScopeFlags;\n // A set of var-declared names in the current lexical scope\n var: Set = new Set();\n // A set of lexically-declared names in the current lexical scope\n lexical: Set = new Set();\n // A set of lexically-declared FunctionDeclaration names in the current lexical scope\n functions: Set = new Set();\n\n constructor(flags: ScopeFlags) {\n this.flags = flags;\n }\n}\n\n// The functions in this module keep track of declared variables in the\n// current scope in order to detect duplicate variable names.\nexport default class ScopeHandler {\n scopeStack: Array = [];\n declare raise: raiseFunction;\n declare inModule: boolean;\n undefinedExports: Map = new Map();\n\n constructor(raise: raiseFunction, inModule: boolean) {\n this.raise = raise;\n this.inModule = inModule;\n }\n\n get inFunction() {\n return (this.currentVarScopeFlags() & SCOPE_FUNCTION) > 0;\n }\n get allowSuper() {\n return (this.currentThisScopeFlags() & SCOPE_SUPER) > 0;\n }\n get allowDirectSuper() {\n return (this.currentThisScopeFlags() & SCOPE_DIRECT_SUPER) > 0;\n }\n get inClass() {\n return (this.currentThisScopeFlags() & SCOPE_CLASS) > 0;\n }\n get inClassAndNotInNonArrowFunction() {\n const flags = this.currentThisScopeFlags();\n return (flags & SCOPE_CLASS) > 0 && (flags & SCOPE_FUNCTION) === 0;\n }\n get inStaticBlock() {\n for (let i = this.scopeStack.length - 1; ; i--) {\n const { flags } = this.scopeStack[i];\n if (flags & SCOPE_STATIC_BLOCK) {\n return true;\n }\n if (flags & (SCOPE_VAR | SCOPE_CLASS)) {\n // function body, module body, class property initializers\n return false;\n }\n }\n }\n get inNonArrowFunction() {\n return (this.currentThisScopeFlags() & SCOPE_FUNCTION) > 0;\n }\n get treatFunctionsAsVar() {\n return this.treatFunctionsAsVarInScope(this.currentScope());\n }\n\n createScope(flags: ScopeFlags): Scope {\n return new Scope(flags);\n }\n // This method will be overwritten by subclasses\n /*:: +createScope: (flags: ScopeFlags) => IScope; */\n\n enter(flags: ScopeFlags) {\n this.scopeStack.push(this.createScope(flags));\n }\n\n exit() {\n this.scopeStack.pop();\n }\n\n // The spec says:\n // > At the top level of a function, or script, function declarations are\n // > treated like var declarations rather than like lexical declarations.\n treatFunctionsAsVarInScope(scope: IScope): boolean {\n return !!(\n scope.flags & SCOPE_FUNCTION ||\n (!this.inModule && scope.flags & SCOPE_PROGRAM)\n );\n }\n\n declareName(name: string, bindingType: BindingTypes, loc: Position) {\n let scope = this.currentScope();\n if (bindingType & BIND_SCOPE_LEXICAL || bindingType & BIND_SCOPE_FUNCTION) {\n this.checkRedeclarationInScope(scope, name, bindingType, loc);\n\n if (bindingType & BIND_SCOPE_FUNCTION) {\n scope.functions.add(name);\n } else {\n scope.lexical.add(name);\n }\n\n if (bindingType & BIND_SCOPE_LEXICAL) {\n this.maybeExportDefined(scope, name);\n }\n } else if (bindingType & BIND_SCOPE_VAR) {\n for (let i = this.scopeStack.length - 1; i >= 0; --i) {\n scope = this.scopeStack[i];\n this.checkRedeclarationInScope(scope, name, bindingType, loc);\n scope.var.add(name);\n this.maybeExportDefined(scope, name);\n\n if (scope.flags & SCOPE_VAR) break;\n }\n }\n if (this.inModule && scope.flags & SCOPE_PROGRAM) {\n this.undefinedExports.delete(name);\n }\n }\n\n maybeExportDefined(scope: IScope, name: string) {\n if (this.inModule && scope.flags & SCOPE_PROGRAM) {\n this.undefinedExports.delete(name);\n }\n }\n\n checkRedeclarationInScope(\n scope: IScope,\n name: string,\n bindingType: BindingTypes,\n loc: Position,\n ) {\n if (this.isRedeclaredInScope(scope, name, bindingType)) {\n this.raise(Errors.VarRedeclaration, { at: loc }, name);\n }\n }\n\n isRedeclaredInScope(\n scope: IScope,\n name: string,\n bindingType: BindingTypes,\n ): boolean {\n if (!(bindingType & BIND_KIND_VALUE)) return false;\n\n if (bindingType & BIND_SCOPE_LEXICAL) {\n return (\n scope.lexical.has(name) ||\n scope.functions.has(name) ||\n scope.var.has(name)\n );\n }\n\n if (bindingType & BIND_SCOPE_FUNCTION) {\n return (\n scope.lexical.has(name) ||\n (!this.treatFunctionsAsVarInScope(scope) && scope.var.has(name))\n );\n }\n\n return (\n (scope.lexical.has(name) &&\n !(\n scope.flags & SCOPE_SIMPLE_CATCH &&\n scope.lexical.values().next().value === name\n )) ||\n (!this.treatFunctionsAsVarInScope(scope) && scope.functions.has(name))\n );\n }\n\n checkLocalExport(id: N.Identifier) {\n const { name } = id;\n const topLevelScope = this.scopeStack[0];\n if (\n !topLevelScope.lexical.has(name) &&\n !topLevelScope.var.has(name) &&\n // In strict mode, scope.functions will always be empty.\n // Modules are strict by default, but the `scriptMode` option\n // can overwrite this behavior.\n !topLevelScope.functions.has(name)\n ) {\n this.undefinedExports.set(name, id.loc.start);\n }\n }\n\n currentScope(): IScope {\n return this.scopeStack[this.scopeStack.length - 1];\n }\n\n // $FlowIgnore\n currentVarScopeFlags(): ScopeFlags {\n for (let i = this.scopeStack.length - 1; ; i--) {\n const { flags } = this.scopeStack[i];\n if (flags & SCOPE_VAR) {\n return flags;\n }\n }\n }\n\n // Could be useful for `arguments`, `this`, `new.target`, `super()`, `super.property`, and `super[property]`.\n // $FlowIgnore\n currentThisScopeFlags(): ScopeFlags {\n for (let i = this.scopeStack.length - 1; ; i--) {\n const { flags } = this.scopeStack[i];\n if (flags & (SCOPE_VAR | SCOPE_CLASS) && !(flags & SCOPE_ARROW)) {\n return flags;\n }\n }\n }\n}\n","// @flow\n\nimport { Position } from \"../../util/location\";\nimport ScopeHandler, { Scope } from \"../../util/scope\";\nimport {\n BIND_FLAGS_FLOW_DECLARE_FN,\n type ScopeFlags,\n type BindingTypes,\n} from \"../../util/scopeflags\";\nimport * as N from \"../../types\";\n\n// Reference implementation: https://github.com/facebook/flow/blob/23aeb2a2ef6eb4241ce178fde5d8f17c5f747fb5/src/typing/env.ml#L536-L584\nclass FlowScope extends Scope {\n // declare function foo(): type;\n declareFunctions: Set = new Set();\n}\n\nexport default class FlowScopeHandler extends ScopeHandler {\n createScope(flags: ScopeFlags): FlowScope {\n return new FlowScope(flags);\n }\n\n declareName(name: string, bindingType: BindingTypes, loc: Position) {\n const scope = this.currentScope();\n if (bindingType & BIND_FLAGS_FLOW_DECLARE_FN) {\n this.checkRedeclarationInScope(scope, name, bindingType, loc);\n this.maybeExportDefined(scope, name);\n scope.declareFunctions.add(name);\n return;\n }\n\n super.declareName(...arguments);\n }\n\n isRedeclaredInScope(\n scope: FlowScope,\n name: string,\n bindingType: BindingTypes,\n ): boolean {\n if (super.isRedeclaredInScope(...arguments)) return true;\n\n if (bindingType & BIND_FLAGS_FLOW_DECLARE_FN) {\n return (\n !scope.declareFunctions.has(name) &&\n (scope.lexical.has(name) || scope.functions.has(name))\n );\n }\n\n return false;\n }\n\n checkLocalExport(id: N.Identifier) {\n if (!this.scopeStack[0].declareFunctions.has(id.name)) {\n super.checkLocalExport(id);\n }\n }\n}\n","// @flow\n\nimport * as charCodes from \"charcodes\";\n\n// Matches a whole line break (where CRLF is considered a single\n// line break). Used to count lines.\nexport const lineBreak = /\\r\\n?|[\\n\\u2028\\u2029]/;\nexport const lineBreakG = new RegExp(lineBreak.source, \"g\");\n\n// https://tc39.github.io/ecma262/#sec-line-terminators\nexport function isNewLine(code: number): boolean {\n switch (code) {\n case charCodes.lineFeed:\n case charCodes.carriageReturn:\n case charCodes.lineSeparator:\n case charCodes.paragraphSeparator:\n return true;\n\n default:\n return false;\n }\n}\n\nexport const skipWhiteSpace = /(?:\\s|\\/\\/.*|\\/\\*[^]*?\\*\\/)*/g;\n\nexport const skipWhiteSpaceInLine =\n /(?:[^\\S\\n\\r\\u2028\\u2029]|\\/\\/.*|\\/\\*.*?\\*\\/)*/y;\n\n// Skip whitespace and single-line comments, including /* no newline here */.\n// After this RegExp matches, its lastIndex points to a line terminator, or\n// the start of multi-line comment (which is effectively a line terminator),\n// or the end of string.\nexport const skipWhiteSpaceToLineBreak = new RegExp(\n // Unfortunately JS doesn't support Perl's atomic /(?>pattern)/ or\n // possessive quantifiers, so we use a trick to prevent backtracking\n // when the look-ahead for line terminator fails.\n \"(?=(\" +\n // Capture the whitespace and comments that should be skipped inside\n // a look-ahead assertion, and then re-match the group as a unit.\n skipWhiteSpaceInLine.source +\n \"))\\\\1\" +\n // Look-ahead for either line terminator, start of multi-line comment,\n // or end of string.\n /(?=[\\n\\r\\u2028\\u2029]|\\/\\*(?!.*?\\*\\/)|$)/.source,\n \"y\", // sticky\n);\n\n// https://tc39.github.io/ecma262/#sec-white-space\nexport function isWhitespace(code: number): boolean {\n switch (code) {\n case 0x0009: // CHARACTER TABULATION\n case 0x000b: // LINE TABULATION\n case 0x000c: // FORM FEED\n case charCodes.space:\n case charCodes.nonBreakingSpace:\n case charCodes.oghamSpaceMark:\n case 0x2000: // EN QUAD\n case 0x2001: // EM QUAD\n case 0x2002: // EN SPACE\n case 0x2003: // EM SPACE\n case 0x2004: // THREE-PER-EM SPACE\n case 0x2005: // FOUR-PER-EM SPACE\n case 0x2006: // SIX-PER-EM SPACE\n case 0x2007: // FIGURE SPACE\n case 0x2008: // PUNCTUATION SPACE\n case 0x2009: // THIN SPACE\n case 0x200a: // HAIR SPACE\n case 0x202f: // NARROW NO-BREAK SPACE\n case 0x205f: // MEDIUM MATHEMATICAL SPACE\n case 0x3000: // IDEOGRAPHIC SPACE\n case 0xfeff: // ZERO WIDTH NO-BREAK SPACE\n return true;\n\n default:\n return false;\n }\n}\n","// @flow\n\nimport type { Options } from \"../options\";\nimport * as N from \"../types\";\nimport type { CommentWhitespace } from \"../parser/comments\";\nimport { Position } from \"../util/location\";\n\nimport { types as ct, type TokContext } from \"./context\";\nimport { tt, type TokenType } from \"./types\";\nimport type { ErrorData, ParsingError } from \"../parser/error\";\n\ntype TopicContextState = {\n // When a topic binding has been currently established,\n // then this is 1. Otherwise, it is 0. This is forwards compatible\n // with a future plugin for multiple lexical topics.\n maxNumOfResolvableTopics: number,\n\n // When a topic binding has been currently established, and if that binding\n // has been used as a topic reference `#`, then this is 0. Otherwise, it is\n // `null`. This is forwards compatible with a future plugin for multiple\n // lexical topics.\n maxTopicIndex: null | 0,\n};\n\nexport default class State {\n strict: boolean;\n curLine: number;\n lineStart: number;\n\n // And, if locations are used, the {line, column} object\n // corresponding to those offsets\n startLoc: Position;\n endLoc: Position;\n\n init({ strictMode, sourceType, startLine, startColumn }: Options): void {\n this.strict =\n strictMode === false\n ? false\n : strictMode === true\n ? true\n : sourceType === \"module\";\n\n this.curLine = startLine;\n this.lineStart = -startColumn;\n this.startLoc = this.endLoc = new Position(startLine, startColumn, 0);\n }\n\n errors: ParsingError[] = [];\n\n // Used to signify the start of a potential arrow function\n potentialArrowAt: number = -1;\n\n // Used to signify the start of an expression which looks like a\n // typed arrow function, but it isn't\n // e.g. a ? (b) : c => d\n // ^\n noArrowAt: number[] = [];\n\n // Used to signify the start of an expression whose params, if it looks like\n // an arrow function, shouldn't be converted to assignable nodes.\n // This is used to defer the validation of typed arrow functions inside\n // conditional expressions.\n // e.g. a ? (b) : c => d\n // ^\n noArrowParamsConversionAt: number[] = [];\n\n // Flags to track\n maybeInArrowParameters: boolean = false;\n inType: boolean = false;\n noAnonFunctionType: boolean = false;\n hasFlowComment: boolean = false;\n isAmbientContext: boolean = false;\n inAbstractClass: boolean = false;\n\n // For the Hack-style pipelines plugin\n topicContext: TopicContextState = {\n maxNumOfResolvableTopics: 0,\n maxTopicIndex: null,\n };\n\n // For the F#-style pipelines plugin\n soloAwait: boolean = false;\n inFSharpPipelineDirectBody: boolean = false;\n\n // Labels in scope.\n labels: Array<{\n kind: ?(\"loop\" | \"switch\"),\n name?: ?string,\n statementStart?: number,\n }> = [];\n\n // Leading decorators. Last element of the stack represents the decorators in current context.\n // Supports nesting of decorators, e.g. @foo(@bar class inner {}) class outer {}\n // where @foo belongs to the outer class and @bar to the inner\n decoratorStack: Array> = [[]];\n\n // Comment store for Program.comments\n comments: Array = [];\n\n // Comment attachment store\n commentStack: Array = [];\n\n // The current position of the tokenizer in the input.\n pos: number = 0;\n\n // Properties of the current token:\n // Its type\n type: TokenType = tt.eof;\n\n // For tokens that include more information than their type, the value\n value: any = null;\n\n // Its start and end offset\n start: number = 0;\n end: number = 0;\n\n // Position information for the previous token\n // $FlowIgnore this is initialized when generating the second token.\n lastTokEndLoc: Position = null;\n // $FlowIgnore this is initialized when generating the second token.\n lastTokStartLoc: Position = null;\n lastTokStart: number = 0;\n\n // The context stack is used to track whether the apostrophe \"`\" starts\n // or ends a string template\n context: Array = [ct.brace];\n // Used to track whether a JSX element is allowed to form\n canStartJSXElement: boolean = true;\n\n // Used to signal to callers of `readWord1` whether the word\n // contained any escape sequences. This is needed because words with\n // escape sequences must not be interpreted as keywords.\n containsEsc: boolean = false;\n\n // This property is used to track the following errors\n // - StrictNumericEscape\n // - StrictOctalLiteral\n //\n // in a literal that occurs prior to/immediately after a \"use strict\" directive.\n\n // todo(JLHwung): set strictErrors to null and avoid recording string errors\n // after a non-directive is parsed\n strictErrors: Map = new Map();\n\n // Tokens length in token store\n tokensLength: number = 0;\n\n curPosition(): Position {\n return new Position(this.curLine, this.pos - this.lineStart, this.pos);\n }\n\n clone(skipArrays?: boolean): State {\n const state = new State();\n const keys = Object.keys(this);\n for (let i = 0, length = keys.length; i < length; i++) {\n const key = keys[i];\n // $FlowIgnore\n let val = this[key];\n\n if (!skipArrays && Array.isArray(val)) {\n val = val.slice();\n }\n\n // $FlowIgnore\n state[key] = val;\n }\n\n return state;\n }\n}\n\nexport type LookaheadState = {\n pos: number,\n value: any,\n type: TokenType,\n start: number,\n end: number,\n /* Used only in readToken_mult_modulo */\n inType: boolean,\n};\n","// @flow\n\n/*:: declare var invariant; */\n\nimport type { Options } from \"../options\";\nimport { Position, createPositionWithColumnOffset } from \"../util/location\";\nimport * as N from \"../types\";\nimport * as charCodes from \"charcodes\";\nimport { isIdentifierStart, isIdentifierChar } from \"../util/identifier\";\nimport {\n tokenIsKeyword,\n tokenLabelName,\n tt,\n keywords as keywordTypes,\n type TokenType,\n} from \"./types\";\nimport { type TokContext } from \"./context\";\nimport ParserErrors, { Errors, type ErrorTemplate } from \"../parser/error\";\nimport { SourceLocation } from \"../util/location\";\nimport {\n lineBreakG,\n isNewLine,\n isWhitespace,\n skipWhiteSpace,\n} from \"../util/whitespace\";\nimport State from \"./state\";\nimport type { LookaheadState } from \"./state\";\n\nconst VALID_REGEX_FLAGS = new Set([\n charCodes.lowercaseG,\n charCodes.lowercaseM,\n charCodes.lowercaseS,\n charCodes.lowercaseI,\n charCodes.lowercaseY,\n charCodes.lowercaseU,\n charCodes.lowercaseD,\n // This is only valid when using the regexpUnicodeSets plugin\n charCodes.lowercaseV,\n]);\n\n// The following character codes are forbidden from being\n// an immediate sibling of NumericLiteralSeparator _\n\nconst forbiddenNumericSeparatorSiblings = {\n decBinOct: [\n charCodes.dot,\n charCodes.uppercaseB,\n charCodes.uppercaseE,\n charCodes.uppercaseO,\n charCodes.underscore, // multiple separators are not allowed\n charCodes.lowercaseB,\n charCodes.lowercaseE,\n charCodes.lowercaseO,\n ],\n hex: [\n charCodes.dot,\n charCodes.uppercaseX,\n charCodes.underscore, // multiple separators are not allowed\n charCodes.lowercaseX,\n ],\n};\n\nconst allowedNumericSeparatorSiblings = {};\nallowedNumericSeparatorSiblings.bin = [\n // 0 - 1\n charCodes.digit0,\n charCodes.digit1,\n];\nallowedNumericSeparatorSiblings.oct = [\n // 0 - 7\n ...allowedNumericSeparatorSiblings.bin,\n\n charCodes.digit2,\n charCodes.digit3,\n charCodes.digit4,\n charCodes.digit5,\n charCodes.digit6,\n charCodes.digit7,\n];\nallowedNumericSeparatorSiblings.dec = [\n // 0 - 9\n ...allowedNumericSeparatorSiblings.oct,\n\n charCodes.digit8,\n charCodes.digit9,\n];\n\nallowedNumericSeparatorSiblings.hex = [\n // 0 - 9, A - F, a - f,\n ...allowedNumericSeparatorSiblings.dec,\n\n charCodes.uppercaseA,\n charCodes.uppercaseB,\n charCodes.uppercaseC,\n charCodes.uppercaseD,\n charCodes.uppercaseE,\n charCodes.uppercaseF,\n\n charCodes.lowercaseA,\n charCodes.lowercaseB,\n charCodes.lowercaseC,\n charCodes.lowercaseD,\n charCodes.lowercaseE,\n charCodes.lowercaseF,\n];\n\n// Object type used to represent tokens. Note that normally, tokens\n// simply exist as properties on the parser object. This is only\n// used for the onToken callback and the external tokenizer.\n\nexport class Token {\n constructor(state: State) {\n this.type = state.type;\n this.value = state.value;\n this.start = state.start;\n this.end = state.end;\n this.loc = new SourceLocation(state.startLoc, state.endLoc);\n }\n\n declare type: TokenType;\n declare value: any;\n declare start: number;\n declare end: number;\n declare loc: SourceLocation;\n}\n\n// ## Tokenizer\n\nexport default class Tokenizer extends ParserErrors {\n // Forward-declarations\n // parser/util.js\n /*::\n +hasPrecedingLineBreak: () => boolean;\n +unexpected: (loc?: ?Position, type?: TokenType) => empty;\n +expectPlugin: (name: string, loc?: Position) => true;\n */\n\n isLookahead: boolean;\n\n // Token store.\n tokens: Array = [];\n\n constructor(options: Options, input: string) {\n super();\n this.state = new State();\n this.state.init(options);\n this.input = input;\n this.length = input.length;\n this.isLookahead = false;\n }\n\n pushToken(token: Token | N.Comment) {\n // Pop out invalid tokens trapped by try-catch parsing.\n // Those parsing branches are mainly created by typescript and flow plugins.\n this.tokens.length = this.state.tokensLength;\n this.tokens.push(token);\n ++this.state.tokensLength;\n }\n\n // Move to the next token\n\n next(): void {\n this.checkKeywordEscapes();\n if (this.options.tokens) {\n this.pushToken(new Token(this.state));\n }\n\n this.state.lastTokStart = this.state.start;\n this.state.lastTokEndLoc = this.state.endLoc;\n this.state.lastTokStartLoc = this.state.startLoc;\n this.nextToken();\n }\n\n // TODO\n\n eat(type: TokenType): boolean {\n if (this.match(type)) {\n this.next();\n return true;\n } else {\n return false;\n }\n }\n\n /**\n * Whether current token matches given type\n *\n * @param {TokenType} type\n * @returns {boolean}\n * @memberof Tokenizer\n */\n match(type: TokenType): boolean {\n return this.state.type === type;\n }\n\n /**\n * Create a LookaheadState from current parser state\n *\n * @param {State} state\n * @returns {LookaheadState}\n * @memberof Tokenizer\n */\n createLookaheadState(state: State): LookaheadState {\n return {\n pos: state.pos,\n value: null,\n type: state.type,\n start: state.start,\n end: state.end,\n context: [this.curContext()],\n inType: state.inType,\n startLoc: state.startLoc,\n lastTokEndLoc: state.lastTokEndLoc,\n curLine: state.curLine,\n lineStart: state.lineStart,\n curPosition: state.curPosition,\n };\n }\n\n /**\n * lookahead peeks the next token, skipping changes to token context and\n * comment stack. For performance it returns a limited LookaheadState\n * instead of full parser state.\n *\n * The { column, line } Loc info is not included in lookahead since such usage\n * is rare. Although it may return other location properties e.g. `curLine` and\n * `lineStart`, these properties are not listed in the LookaheadState interface\n * and thus the returned value is _NOT_ reliable.\n *\n * The tokenizer should make best efforts to avoid using any parser state\n * other than those defined in LookaheadState\n *\n * @returns {LookaheadState}\n * @memberof Tokenizer\n */\n lookahead(): LookaheadState {\n const old = this.state;\n // For performance we use a simpified tokenizer state structure\n // $FlowIgnore\n this.state = this.createLookaheadState(old);\n\n this.isLookahead = true;\n this.nextToken();\n this.isLookahead = false;\n\n const curr = this.state;\n this.state = old;\n return curr;\n }\n\n nextTokenStart(): number {\n return this.nextTokenStartSince(this.state.pos);\n }\n\n nextTokenStartSince(pos: number): number {\n skipWhiteSpace.lastIndex = pos;\n return skipWhiteSpace.test(this.input) ? skipWhiteSpace.lastIndex : pos;\n }\n\n lookaheadCharCode(): number {\n return this.input.charCodeAt(this.nextTokenStart());\n }\n\n codePointAtPos(pos: number): number {\n // The implementation is based on\n // https://source.chromium.org/chromium/chromium/src/+/master:v8/src/builtins/builtins-string-gen.cc;l=1455;drc=221e331b49dfefadbc6fa40b0c68e6f97606d0b3;bpv=0;bpt=1\n // We reimplement `codePointAt` because `codePointAt` is a V8 builtin which is not inlined by TurboFan (as of M91)\n // since `input` is mostly ASCII, an inlined `charCodeAt` wins here\n let cp = this.input.charCodeAt(pos);\n if ((cp & 0xfc00) === 0xd800 && ++pos < this.input.length) {\n const trail = this.input.charCodeAt(pos);\n if ((trail & 0xfc00) === 0xdc00) {\n cp = 0x10000 + ((cp & 0x3ff) << 10) + (trail & 0x3ff);\n }\n }\n return cp;\n }\n\n // Toggle strict mode. Re-reads the next number or string to please\n // pedantic tests (`\"use strict\"; 010;` should fail).\n\n setStrict(strict: boolean): void {\n this.state.strict = strict;\n if (strict) {\n // Throw an error for any string decimal escape found before/immediately\n // after a \"use strict\" directive. Strict mode will be set at parse\n // time for any literals that occur after the next node of the strict\n // directive.\n this.state.strictErrors.forEach(({ message, loc }) =>\n /* eslint-disable @babel/development-internal/dry-error-messages */\n this.raise(message, { at: loc }),\n );\n this.state.strictErrors.clear();\n }\n }\n\n curContext(): TokContext {\n return this.state.context[this.state.context.length - 1];\n }\n\n // Read a single token, updating the parser object's token-related\n // properties.\n\n nextToken(): void {\n this.skipSpace();\n this.state.start = this.state.pos;\n if (!this.isLookahead) this.state.startLoc = this.state.curPosition();\n if (this.state.pos >= this.length) {\n this.finishToken(tt.eof);\n return;\n }\n\n this.getTokenFromCode(this.codePointAtPos(this.state.pos));\n }\n\n skipBlockComment(): N.CommentBlock | void {\n let startLoc;\n if (!this.isLookahead) startLoc = this.state.curPosition();\n const start = this.state.pos;\n const end = this.input.indexOf(\"*/\", start + 2);\n if (end === -1) {\n // We have to call this again here because startLoc may not be set...\n // This seems to be for performance reasons:\n // https://github.com/babel/babel/commit/acf2a10899f696a8aaf34df78bf9725b5ea7f2da\n throw this.raise(Errors.UnterminatedComment, {\n at: this.state.curPosition(),\n });\n }\n\n this.state.pos = end + 2;\n lineBreakG.lastIndex = start + 2;\n while (lineBreakG.test(this.input) && lineBreakG.lastIndex <= end) {\n ++this.state.curLine;\n this.state.lineStart = lineBreakG.lastIndex;\n }\n\n // If we are doing a lookahead right now we need to advance the position (above code)\n // but we do not want to push the comment to the state.\n if (this.isLookahead) return;\n /*:: invariant(startLoc) */\n\n const comment = {\n type: \"CommentBlock\",\n value: this.input.slice(start + 2, end),\n start,\n end: end + 2,\n loc: new SourceLocation(startLoc, this.state.curPosition()),\n };\n if (this.options.tokens) this.pushToken(comment);\n return comment;\n }\n\n skipLineComment(startSkip: number): N.CommentLine | void {\n const start = this.state.pos;\n let startLoc;\n if (!this.isLookahead) startLoc = this.state.curPosition();\n let ch = this.input.charCodeAt((this.state.pos += startSkip));\n if (this.state.pos < this.length) {\n while (!isNewLine(ch) && ++this.state.pos < this.length) {\n ch = this.input.charCodeAt(this.state.pos);\n }\n }\n\n // If we are doing a lookahead right now we need to advance the position (above code)\n // but we do not want to push the comment to the state.\n if (this.isLookahead) return;\n /*:: invariant(startLoc) */\n\n const end = this.state.pos;\n const value = this.input.slice(start + startSkip, end);\n\n const comment = {\n type: \"CommentLine\",\n value,\n start,\n end,\n loc: new SourceLocation(startLoc, this.state.curPosition()),\n };\n if (this.options.tokens) this.pushToken(comment);\n return comment;\n }\n\n // Called at the start of the parse and after every token. Skips\n // whitespace and comments, and.\n\n skipSpace(): void {\n const spaceStart = this.state.pos;\n const comments = [];\n loop: while (this.state.pos < this.length) {\n const ch = this.input.charCodeAt(this.state.pos);\n switch (ch) {\n case charCodes.space:\n case charCodes.nonBreakingSpace:\n case charCodes.tab:\n ++this.state.pos;\n break;\n case charCodes.carriageReturn:\n if (\n this.input.charCodeAt(this.state.pos + 1) === charCodes.lineFeed\n ) {\n ++this.state.pos;\n }\n // fall through\n case charCodes.lineFeed:\n case charCodes.lineSeparator:\n case charCodes.paragraphSeparator:\n ++this.state.pos;\n ++this.state.curLine;\n this.state.lineStart = this.state.pos;\n break;\n\n case charCodes.slash:\n switch (this.input.charCodeAt(this.state.pos + 1)) {\n case charCodes.asterisk: {\n const comment = this.skipBlockComment();\n if (comment !== undefined) {\n this.addComment(comment);\n if (this.options.attachComment) comments.push(comment);\n }\n break;\n }\n\n case charCodes.slash: {\n const comment = this.skipLineComment(2);\n if (comment !== undefined) {\n this.addComment(comment);\n if (this.options.attachComment) comments.push(comment);\n }\n break;\n }\n\n default:\n break loop;\n }\n break;\n\n default:\n if (isWhitespace(ch)) {\n ++this.state.pos;\n } else if (ch === charCodes.dash && !this.inModule) {\n const pos = this.state.pos;\n if (\n this.input.charCodeAt(pos + 1) === charCodes.dash &&\n this.input.charCodeAt(pos + 2) === charCodes.greaterThan &&\n (spaceStart === 0 || this.state.lineStart > spaceStart)\n ) {\n // A `-->` line comment\n const comment = this.skipLineComment(3);\n if (comment !== undefined) {\n this.addComment(comment);\n if (this.options.attachComment) comments.push(comment);\n }\n } else {\n break loop;\n }\n } else if (ch === charCodes.lessThan && !this.inModule) {\n const pos = this.state.pos;\n if (\n this.input.charCodeAt(pos + 1) === charCodes.exclamationMark &&\n this.input.charCodeAt(pos + 2) === charCodes.dash &&\n this.input.charCodeAt(pos + 3) === charCodes.dash\n ) {\n // `
+
+
+
+```
+
+### Features Supported
+
+- JSX spread attributes are compiled to Object.assign() instead of a helper.
+- Default, destructured and optional parameters are all natively supported.
+- Tagged Templates are fully supported, patched for Safari 10+ and Edge 16+.
+- async/await is supported without being transpiled to generators.
+- Function name inference works as expected, including Arrow Functions.
+
+### Installation & Usage
+
+Install the preset from [npm](https://www.npmjs.com/package/@babel/preset-modules):
+
+```sh
+npm install @babel/preset-modules --save-dev
+```
+
+To use the preset, add it to your [Babel Configuration](https://babeljs.io/docs/en/configuration):
+
+```js
+{
+ "presets": [
+ "@babel/preset-modules"
+ ]
+}
+```
+
+If you're implementing the module/nomodule pattern, your configuration might look something like this:
+
+```js
+{
+ "env": {
+ "modern": {
+ "presets": [
+ "@babel/preset-modules"
+ ]
+ },
+ "legacy": {
+ "presets": [
+ "@babel/preset-env"
+ ]
+ }
+ }
+}
+```
+
+### Options
+
+There's a single Boolean `loose` option, which defaults to `false`. Passing `true` further reduces output size.
+
+The `loose` setting turns off a rarely-needed function name workaround for older versions of Edge. If you're not relying on `Function.prototype.name`, it's worth enabling loose mode.
+
+### How does it work?
+
+Babel’s `preset-env` is great, since it lets you define which Babel features are needed based on a browser support target. In order to make that plumbing work automatically, the preset has configuration that groups all of the new JavaScript syntax features into collections of related syntax transforms. These groups are fairly large, for example "function arguments" includes destructured, default and rest parameters. The groupings come from the fact that Babel’s transforms often rely on other transforms, so they can’t always be applied in isolation.
+
+From this grouping information, Babel enables or disables each group based on the browser support target you specify to preset-env’s [targets](https://babeljs.io/docs/en/babel-preset-env#targets) option. For modern output, the [targets.esmodules](https://babeljs.io/docs/en/babel-preset-env#targetsesmodules) option is effectively an alias for the set of browsers that support ES Modules: Edge 16+, Safari 10.1+, Firefox 60+ and Chrome 61+.
+
+Here's the problem: if any version of any browser in that list contains a bug triggered by modern syntax, the only solution we have is to enable the corresponding transform group that fixes that bug. This means that fundamentally, preset-env converts code to ES5 in order to get around syntax bugs in ES2017. Since that's the only solution at our disposal, eventually it becomes overused.
+
+For example, all of the new syntax features relating to function parameters are grouped into the same Babel plugin (`@babel/plugin-transform-function-parameters`). That means because Edge 16 & 17 support ES Modules but have a bug related to parsing shorthand destructured parameters with default values within arrow functions, all functions get compiled from the new compact argument syntaxes down to ES5:
+
+```js
+// this breaks in Edge 16:
+const foo = ({ a = 1 }) => {};
+
+// .. but this doesn't:
+function foo({ a = 1, b }, ...args) {}
+
+// ... and neither does this:
+const foo = ({ a: a = 1 }) => {};
+```
+
+In fact, there are 23 syntax improvements for function parameters in ES2017, and only one of them is broken in ES Modules-supporting browsers. It seems unfortunate to transpile all those great features down to ES5 just for one browser!
+
+This plugin takes a different approach than we've historically taken with JavaScript: it transpiles the broken syntax to the closest _non-broken modern syntax_. In the above case, here's what is generated to fix all ES Modules-supporting browsers:
+
+**input:**
+
+```js
+const foo = ({ a = 1 }, b = 2, ...args) => [a,b,args];
+```
+
+**output:**
+
+```js
+const foo = ({ a: a = 1 }, b = 2, ...args) => [a,b,args];
+```
+
+That output works in all ES Modules-supporting browsers, and is only **59 bytes** minified & gzipped.
+
+> Compare this to `@babel/preset-env`'s `targets.esmodules` output (**147 bytes** minified & gzipped):
+>
+> ```js
+>const foo = function foo(_ref, b) {
+> let { a = 1 } = _ref;
+>
+> if (b === void 0) { b = 2; }
+>
+> for (
+> var _len = arguments.length,
+> args = new Array(_len > 2 ? _len - 2 : 0),
+> _key = 2; _key < _len; _key++
+> ) {
+> args[_key - 2] = arguments[_key];
+> }
+>
+> return [a, b, args];
+>};
+>````
+
+The result is improved bundle size and performance, while supporting the same browsers.
+
+
+### Important: Minification
+
+The output generated by this preset includes workarounds for Safari 10, however minifiers like Terser sometimes remove these workarounds. In order to avoid shipping broken code, it's important to tell Terser to preserve the workarounds, which can be done via the `safari10` option.
+
+It's also generally the case that minifiers are configured to output ES5 by default, so you'll want to change the output syntax to ES2017.
+
+With [Terser's Node API](https://github.com/terser/terser#minify-options):
+
+```js
+terser.minify({
+ ecma: 2017,
+ safari10: true
+})
+```
+
+With [Terser CLI](https://npm.im/terser):
+
+```sh
+terser --ecma 2017 --safari10 ...
+```
+
+With [terser-webpack-plugin](https://webpack.js.org/plugins/terser-webpack-plugin/):
+
+```js
+module.exports = {
+ optimization: {
+ minimizer: [
+ new TerserPlugin({
+ terserOptions: {
+ ecma: 2017,
+ safari10: true
+ }
+ })
+ ]
+ }
+};
+```
+
+All of the above configurations also apply to [uglify-es](https://github.com/mishoo/UglifyJS2/tree/harmony).
+UglifyJS (2.x and prior) does not support modern JavaScript, so it cannot be used in conjunction with this preset.
diff --git a/node_modules/@babel/preset-modules/lib/index.js b/node_modules/@babel/preset-modules/lib/index.js
new file mode 100644
index 000000000..a4c63e76e
--- /dev/null
+++ b/node_modules/@babel/preset-modules/lib/index.js
@@ -0,0 +1,27 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _path = _interopRequireDefault(require("path"));
+
+var _helperPluginUtils = require("@babel/helper-plugin-utils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * @babel/preset-modules produces clean, minimal output for ES Modules-supporting browsers.
+ * @param {Object} [options]
+ * @param {boolean} [options.loose=false] Loose mode skips seldom-needed transforms that increase output size.
+ */
+var _default = (0, _helperPluginUtils.declare)((api, opts) => {
+ api.assertVersion(7);
+ const loose = opts.loose === true;
+ return {
+ plugins: [_path.default.resolve(__dirname, "./plugins/transform-edge-default-parameters"), _path.default.resolve(__dirname, "./plugins/transform-tagged-template-caching"), _path.default.resolve(__dirname, "./plugins/transform-jsx-spread"), _path.default.resolve(__dirname, "./plugins/transform-safari-for-shadowing"), _path.default.resolve(__dirname, "./plugins/transform-safari-block-shadowing"), _path.default.resolve(__dirname, "./plugins/transform-async-arrows-in-class"), !loose && _path.default.resolve(__dirname, "./plugins/transform-edge-function-name"), // Proposals
+ require.resolve("@babel/plugin-proposal-unicode-property-regex"), require.resolve("@babel/plugin-transform-dotall-regex")].filter(Boolean)
+ };
+});
+
+exports.default = _default;
+module.exports = exports.default;
\ No newline at end of file
diff --git a/node_modules/@babel/preset-modules/lib/plugins/transform-async-arrows-in-class/index.js b/node_modules/@babel/preset-modules/lib/plugins/transform-async-arrows-in-class/index.js
new file mode 100644
index 000000000..69774046f
--- /dev/null
+++ b/node_modules/@babel/preset-modules/lib/plugins/transform-async-arrows-in-class/index.js
@@ -0,0 +1,45 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+/**
+ * Safari 10.3 had an issue where async arrow function expressions within any class method would throw.
+ * After an initial fix, any references to the instance via `this` within those methods would also throw.
+ * This is fixed by converting arrow functions in class methods into equivalent function expressions.
+ * @see https://bugs.webkit.org/show_bug.cgi?id=166879
+ *
+ * @example
+ * class X{ a(){ async () => {}; } } // throws
+ * class X{ a(){ async function() {}; } } // works
+ *
+ * @example
+ * class X{ a(){
+ * async () => this.a; // throws
+ * } }
+ * class X{ a(){
+ * var _this=this;
+ * async function() { return _this.a }; // works
+ * } }
+ */
+const OPTS = {
+ allowInsertArrow: false,
+ specCompliant: false
+};
+
+var _default = ({
+ types: t
+}) => ({
+ name: "transform-async-arrows-in-class",
+ visitor: {
+ ArrowFunctionExpression(path) {
+ if (path.node.async && path.findParent(t.isClassMethod)) {
+ path.arrowFunctionToExpression(OPTS);
+ }
+ }
+
+ }
+});
+
+exports.default = _default;
+module.exports = exports.default;
\ No newline at end of file
diff --git a/node_modules/@babel/preset-modules/lib/plugins/transform-edge-default-parameters/index.js b/node_modules/@babel/preset-modules/lib/plugins/transform-edge-default-parameters/index.js
new file mode 100644
index 000000000..639361384
--- /dev/null
+++ b/node_modules/@babel/preset-modules/lib/plugins/transform-edge-default-parameters/index.js
@@ -0,0 +1,36 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+/**
+ * Converts destructured parameters with default values to non-shorthand syntax.
+ * This fixes the only arguments-related bug in ES Modules-supporting browsers (Edge 16 & 17).
+ * Use this plugin instead of @babel/plugin-transform-parameters when targeting ES Modules.
+ */
+var _default = ({
+ types: t
+}) => {
+ const isArrowParent = p => p.parentKey === "params" && p.parentPath && t.isArrowFunctionExpression(p.parentPath);
+
+ return {
+ name: "transform-edge-default-parameters",
+ visitor: {
+ AssignmentPattern(path) {
+ const arrowArgParent = path.find(isArrowParent);
+
+ if (arrowArgParent && path.parent.shorthand) {
+ // In Babel 7+, there is no way to force non-shorthand properties.
+ path.parent.shorthand = false;
+ (path.parent.extra || {}).shorthand = false; // So, to ensure non-shorthand, rename the local identifier so it no longer matches:
+
+ path.scope.rename(path.parent.key.name);
+ }
+ }
+
+ }
+ };
+};
+
+exports.default = _default;
+module.exports = exports.default;
\ No newline at end of file
diff --git a/node_modules/@babel/preset-modules/lib/plugins/transform-edge-function-name/index.js b/node_modules/@babel/preset-modules/lib/plugins/transform-edge-function-name/index.js
new file mode 100644
index 000000000..acc319669
--- /dev/null
+++ b/node_modules/@babel/preset-modules/lib/plugins/transform-edge-function-name/index.js
@@ -0,0 +1,42 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+/**
+ * Edge 16 & 17 do not infer function.name from variable assignment.
+ * All other `function.name` behavior works fine, so we can skip most of @babel/transform-function-name.
+ * @see https://kangax.github.io/compat-table/es6/#test-function_name_property_variables_(function)
+ *
+ * Note: contrary to various Github issues, Edge 16+ *does* correctly infer the name of Arrow Functions.
+ * The variable declarator name inference issue only affects function expressions, so that's all we fix here.
+ *
+ * A Note on Minification: Terser undoes this transform *by default* unless `keep_fnames` is set to true.
+ * There is by design - if Function.name is critical to your application, you must configure
+ * your minifier to preserve function names.
+ */
+var _default = ({
+ types: t
+}) => ({
+ name: "transform-edge-function-name",
+ visitor: {
+ FunctionExpression: {
+ exit(path) {
+ if (!path.node.id && t.isIdentifier(path.parent.id)) {
+ const id = t.cloneNode(path.parent.id);
+ const binding = path.scope.getBinding(id.name); // if the binding gets reassigned anywhere, rename it
+
+ if (binding == null ? void 0 : binding.constantViolations.length) {
+ path.scope.rename(id.name);
+ }
+
+ path.node.id = id;
+ }
+ }
+
+ }
+ }
+});
+
+exports.default = _default;
+module.exports = exports.default;
\ No newline at end of file
diff --git a/node_modules/@babel/preset-modules/lib/plugins/transform-jsx-spread/index.js b/node_modules/@babel/preset-modules/lib/plugins/transform-jsx-spread/index.js
new file mode 100644
index 000000000..fcb6af17c
--- /dev/null
+++ b/node_modules/@babel/preset-modules/lib/plugins/transform-jsx-spread/index.js
@@ -0,0 +1,115 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _esutils = _interopRequireDefault(require("esutils"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * Converts JSX Spread arguments into Object Spread, avoiding Babel's helper or Object.assign injection.
+ * Input:
+ *
+ * Output:
+ *
+ * ...which Babel converts to:
+ * h("div", { a: "1", ...b })
+ */
+var _default = ({
+ types: t
+}) => {
+ // converts a set of JSXAttributes to an Object.assign() call
+ function convertAttributesAssign(attributes) {
+ const args = [];
+
+ for (let i = 0, current; i < attributes.length; i++) {
+ const node = attributes[i];
+
+ if (t.isJSXSpreadAttribute(node)) {
+ // the first attribute is a spread, avoid copying all other attributes onto it
+ if (i === 0) {
+ args.push(t.objectExpression([]));
+ }
+
+ current = null;
+ args.push(node.argument);
+ } else {
+ const name = getAttributeName(node);
+ const value = getAttributeValue(node);
+
+ if (!current) {
+ current = t.objectExpression([]);
+ args.push(current);
+ }
+
+ current.properties.push(t.objectProperty(name, value));
+ }
+ }
+
+ return t.callExpression(t.memberExpression(t.identifier("Object"), t.identifier("assign")), args);
+ } // Converts a JSXAttribute to the equivalent ObjectExpression property
+
+
+ function convertAttributeSpread(node) {
+ if (t.isJSXSpreadAttribute(node)) {
+ return t.spreadElement(node.argument);
+ }
+
+ const name = getAttributeName(node);
+ const value = getAttributeValue(node);
+ return t.inherits(t.objectProperty(name, value), node);
+ } // Convert a JSX attribute name to an Object expression property name
+
+
+ function getAttributeName(node) {
+ if (t.isJSXNamespacedName(node.name)) {
+ return t.stringLiteral(node.name.namespace.name + ":" + node.name.name.name);
+ }
+
+ if (_esutils.default.keyword.isIdentifierNameES6(node.name.name)) {
+ return t.identifier(node.name.name);
+ }
+
+ return t.stringLiteral(node.name.name);
+ } // Convert a JSX attribute value to a JavaScript expression value
+
+
+ function getAttributeValue(node) {
+ let value = node.value || t.booleanLiteral(true);
+
+ if (t.isJSXExpressionContainer(value)) {
+ value = value.expression;
+ } else if (t.isStringLiteral(value)) {
+ value.value = value.value.replace(/\n\s+/g, " "); // "raw" JSXText should not be used from a StringLiteral because it needs to be escaped.
+
+ if (value.extra && value.extra.raw) {
+ delete value.extra.raw;
+ }
+ }
+
+ return value;
+ }
+
+ return {
+ name: "transform-jsx-spread",
+ visitor: {
+ JSXOpeningElement(path, state) {
+ const useSpread = state.opts.useSpread === true;
+ const hasSpread = path.node.attributes.some(attr => t.isJSXSpreadAttribute(attr)); // ignore JSX Elements without spread or with lone spread:
+
+ if (!hasSpread || path.node.attributes.length === 1) return;
+
+ if (useSpread) {
+ path.node.attributes = [t.jsxSpreadAttribute(t.objectExpression(path.node.attributes.map(convertAttributeSpread)))];
+ } else {
+ path.node.attributes = [t.jsxSpreadAttribute(convertAttributesAssign(path.node.attributes))];
+ }
+ }
+
+ }
+ };
+};
+
+exports.default = _default;
+module.exports = exports.default;
\ No newline at end of file
diff --git a/node_modules/@babel/preset-modules/lib/plugins/transform-safari-block-shadowing/index.js b/node_modules/@babel/preset-modules/lib/plugins/transform-safari-block-shadowing/index.js
new file mode 100644
index 000000000..932cb8267
--- /dev/null
+++ b/node_modules/@babel/preset-modules/lib/plugins/transform-safari-block-shadowing/index.js
@@ -0,0 +1,47 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = _default;
+
+/**
+ * Fixes block-shadowed let/const bindings in Safari 10/11.
+ * https://kangax.github.io/compat-table/es6/#test-let_scope_shadow_resolution
+ */
+function _default({
+ types: t
+}) {
+ return {
+ name: "transform-safari-block-shadowing",
+ visitor: {
+ VariableDeclarator(path) {
+ // the issue only affects let and const bindings:
+ const kind = path.parent.kind;
+ if (kind !== "let" && kind !== "const") return; // ignore non-block-scoped bindings:
+
+ const block = path.scope.block;
+ if (t.isFunction(block) || t.isProgram(block)) return;
+ const bindings = t.getOuterBindingIdentifiers(path.node.id);
+
+ for (const name of Object.keys(bindings)) {
+ let scope = path.scope; // ignore parent bindings (note: impossible due to let/const?)
+
+ if (!scope.hasOwnBinding(name)) continue; // check if shadowed within the nearest function/program boundary
+
+ while (scope = scope.parent) {
+ if (scope.hasOwnBinding(name)) {
+ path.scope.rename(name);
+ break;
+ }
+
+ if (t.isFunction(scope.block) || t.isProgram(scope.block)) {
+ break;
+ }
+ }
+ }
+ }
+
+ }
+ };
+}
+
+module.exports = exports.default;
\ No newline at end of file
diff --git a/node_modules/@babel/preset-modules/lib/plugins/transform-safari-for-shadowing/index.js b/node_modules/@babel/preset-modules/lib/plugins/transform-safari-for-shadowing/index.js
new file mode 100644
index 000000000..43c33e5bd
--- /dev/null
+++ b/node_modules/@babel/preset-modules/lib/plugins/transform-safari-for-shadowing/index.js
@@ -0,0 +1,42 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+/**
+ * Safari ~11 has an issue where variable declarations in a For statement throw if they shadow parameters.
+ * This is fixed by renaming any declarations in the left/init part of a For* statement so they don't shadow.
+ * @see https://bugs.webkit.org/show_bug.cgi?id=171041
+ *
+ * @example
+ * e => { for (let e of []) e } // throws
+ * e => { for (let _e of []) _e } // works
+ */
+function handle(declaration) {
+ if (!declaration.isVariableDeclaration()) return;
+ const fn = declaration.getFunctionParent();
+ const {
+ name
+ } = declaration.node.declarations[0].id; // check if there is a shadowed binding coming from a parameter
+
+ if (fn && fn.scope.hasOwnBinding(name) && fn.scope.getOwnBinding(name).kind === "param") {
+ declaration.scope.rename(name);
+ }
+}
+
+var _default = () => ({
+ name: "transform-safari-for-shadowing",
+ visitor: {
+ ForXStatement(path) {
+ handle(path.get("left"));
+ },
+
+ ForStatement(path) {
+ handle(path.get("init"));
+ }
+
+ }
+});
+
+exports.default = _default;
+module.exports = exports.default;
\ No newline at end of file
diff --git a/node_modules/@babel/preset-modules/lib/plugins/transform-tagged-template-caching/index.js b/node_modules/@babel/preset-modules/lib/plugins/transform-tagged-template-caching/index.js
new file mode 100644
index 000000000..249a6c3c0
--- /dev/null
+++ b/node_modules/@babel/preset-modules/lib/plugins/transform-tagged-template-caching/index.js
@@ -0,0 +1,75 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+/**
+ * Converts destructured parameters with default values to non-shorthand syntax.
+ * This fixes the only Tagged Templates-related bug in ES Modules-supporting browsers (Safari 10 & 11).
+ * Use this plugin instead of `@babel/plugin-transform-template-literals` when targeting ES Modules.
+ *
+ * @example
+ * // Bug 1: Safari 10/11 doesn't reliably return the same Strings value.
+ * // The value changes depending on invocation and function optimization state.
+ * function f() { return Object`` }
+ * f() === new f() // false, should be true.
+ *
+ * @example
+ * // Bug 2: Safari 10/11 use the same cached strings value when the string parts are the same.
+ * // This behavior comes from an earlier version of the spec, and can cause tricky bugs.
+ * Object``===Object`` // true, should be false.
+ *
+ * Benchmarks: https://jsperf.com/compiled-tagged-template-performance
+ */
+var _default = ({
+ types: t
+}) => ({
+ name: "transform-tagged-template-caching",
+ visitor: {
+ TaggedTemplateExpression(path, state) {
+ // tagged templates we've already dealt with
+ let processed = state.get("processed");
+
+ if (!processed) {
+ processed = new WeakSet();
+ state.set("processed", processed);
+ }
+
+ if (processed.has(path.node)) return path.skip(); // Grab the expressions from the original tag.
+ // tag`a${'hello'}` // ['hello']
+
+ const expressions = path.node.quasi.expressions; // Create an identity function helper:
+ // identity = t => t
+
+ let identity = state.get("identity");
+
+ if (!identity) {
+ identity = path.scope.getProgramParent().generateDeclaredUidIdentifier("_");
+ state.set("identity", identity);
+ const binding = path.scope.getBinding(identity.name);
+ binding.path.get("init").replaceWith(t.arrowFunctionExpression( // re-use the helper identifier for compressability
+ [t.identifier("t")], t.identifier("t")));
+ } // Use the identity function helper to get a reference to the template's Strings.
+ // We replace all expressions with `0` ensure Strings has the same shape.
+ // identity`a${0}`
+
+
+ const template = t.taggedTemplateExpression(t.cloneNode(identity), t.templateLiteral(path.node.quasi.quasis, expressions.map(() => t.numericLiteral(0))));
+ processed.add(template); // Install an inline cache at the callsite using the global variable:
+ // _t || (_t = identity`a${0}`)
+
+ const ident = path.scope.getProgramParent().generateDeclaredUidIdentifier("t");
+ path.scope.getBinding(ident.name).path.parent.kind = "let";
+ const inlineCache = t.logicalExpression("||", ident, t.assignmentExpression("=", t.cloneNode(ident), template)); // The original tag function becomes a plain function call.
+ // The expressions omitted from the cached Strings tag are directly applied as arguments.
+ // tag(_t || (_t = Object`a${0}`), 'hello')
+
+ const node = t.callExpression(path.node.tag, [inlineCache, ...expressions]);
+ path.replaceWith(node);
+ }
+
+ }
+});
+
+exports.default = _default;
+module.exports = exports.default;
\ No newline at end of file
diff --git a/node_modules/@babel/preset-modules/package.json b/node_modules/@babel/preset-modules/package.json
new file mode 100644
index 000000000..6be92883a
--- /dev/null
+++ b/node_modules/@babel/preset-modules/package.json
@@ -0,0 +1,106 @@
+{
+ "name": "@babel/preset-modules",
+ "version": "0.1.5",
+ "description": "A Babel preset that targets modern browsers by fixing engine bugs.",
+ "main": "lib/index.js",
+ "license": "MIT",
+ "scripts": {
+ "start": "concurrently -r 'npm:watch:* -s'",
+ "build": "babel src -d lib --ignore '**/*.test.js'",
+ "test": "eslint src test && jest --colors",
+ "test:browser": "cd test/browser && karmatic --no-coverage --browsers chrome:headless,sauce-chrome-61,sauce-firefox-60,sauce-safari-10,sauce-safari-11,sauce-edge-16,sauce-edge-17 '**/*.js'",
+ "test:local": "cd test/browser && karmatic --no-coverage '**/*.js'",
+ "test:safari": "npm run test:local -- --browsers sauce-safari-10",
+ "test:edge": "npm run test:local -- --browsers sauce-edge-16",
+ "watch:test": "jest --watch",
+ "watch:build": "npm run -s build -- -w"
+ },
+ "repository": {
+ "type": "git",
+ "url": "https://github.com/babel/preset-modules.git"
+ },
+ "keywords": [
+ "babel",
+ "preset",
+ "preset-env",
+ "modern",
+ "modules",
+ "ES Modules",
+ "module/nomodule"
+ ],
+ "files": [
+ "src",
+ "lib"
+ ],
+ "lint-staged": {
+ "*.js": [
+ "eslint --format=codeframe"
+ ]
+ },
+ "husky": {
+ "hooks": {
+ "pre-commit": "lint-staged"
+ }
+ },
+ "jest": {
+ "testEnvironment": "node",
+ "roots": [
+ "src",
+ "test"
+ ]
+ },
+ "eslintConfig": {
+ "extends": "developit",
+ "rules": {
+ "no-console": 0,
+ "new-cap": 0
+ }
+ },
+ "eslintIgnore": [
+ "test/fixtures/**/*",
+ "test/integration/**/*"
+ ],
+ "authors": [
+ "Jason Miller "
+ ],
+ "peerDependencies": {
+ "@babel/core": "^7.0.0-0"
+ },
+ "devDependencies": {
+ "@babel/cli": "^7.7.0",
+ "@babel/core": "^7.7.2",
+ "@babel/helper-fixtures": "^7.6.3",
+ "@babel/helper-plugin-test-runner": "^7.14.5",
+ "@babel/plugin-transform-modules-commonjs": "^7.5.0",
+ "@babel/plugin-transform-react-jsx": "^7.7.0",
+ "@babel/preset-env": "^7.9.6",
+ "acorn-jsx": "^5.0.1",
+ "babel-eslint": "^10.0.3",
+ "babel-plugin-add-module-exports": "^1.0.2",
+ "chalk": "^2.4.2",
+ "concurrently": "^4.1.0",
+ "eslint": "^6.6.0",
+ "eslint-config-babel": "^9.0.0",
+ "eslint-plugin-flowtype": "3",
+ "eslint-plugin-import": "^2.18.2",
+ "eslint-plugin-prettier": "^3.1.1",
+ "gzip-size": "^5.1.1",
+ "if-env": "^1.0.4",
+ "jest": "^24.8.0",
+ "karmatic": "^1.4.0",
+ "prettier": "^1.19.1",
+ "pretty-bytes": "^5.2.0",
+ "rollup": "^1.16.3",
+ "rollup-plugin-babel": "^4.3.3",
+ "rollup-plugin-node-resolve": "^5.2.0",
+ "terser": "^4.0.2",
+ "webpack": "^4.35.0"
+ },
+ "dependencies": {
+ "@babel/helper-plugin-utils": "^7.0.0",
+ "@babel/plugin-proposal-unicode-property-regex": "^7.4.4",
+ "@babel/plugin-transform-dotall-regex": "^7.4.4",
+ "@babel/types": "^7.4.4",
+ "esutils": "^2.0.2"
+ }
+}
diff --git a/node_modules/@babel/preset-modules/src/index.js b/node_modules/@babel/preset-modules/src/index.js
new file mode 100644
index 000000000..8dd7bedb0
--- /dev/null
+++ b/node_modules/@babel/preset-modules/src/index.js
@@ -0,0 +1,30 @@
+import path from "path";
+import { declare } from "@babel/helper-plugin-utils";
+
+/**
+ * @babel/preset-modules produces clean, minimal output for ES Modules-supporting browsers.
+ * @param {Object} [options]
+ * @param {boolean} [options.loose=false] Loose mode skips seldom-needed transforms that increase output size.
+ */
+export default declare((api, opts) => {
+ api.assertVersion(7);
+
+ const loose = opts.loose === true;
+
+ return {
+ plugins: [
+ path.resolve(__dirname, "./plugins/transform-edge-default-parameters"),
+ path.resolve(__dirname, "./plugins/transform-tagged-template-caching"),
+ path.resolve(__dirname, "./plugins/transform-jsx-spread"),
+ path.resolve(__dirname, "./plugins/transform-safari-for-shadowing"),
+ path.resolve(__dirname, "./plugins/transform-safari-block-shadowing"),
+ path.resolve(__dirname, "./plugins/transform-async-arrows-in-class"),
+ !loose &&
+ path.resolve(__dirname, "./plugins/transform-edge-function-name"),
+
+ // Proposals
+ require.resolve("@babel/plugin-proposal-unicode-property-regex"),
+ require.resolve("@babel/plugin-transform-dotall-regex"),
+ ].filter(Boolean),
+ };
+});
diff --git a/node_modules/@babel/preset-modules/src/plugins/transform-async-arrows-in-class/index.js b/node_modules/@babel/preset-modules/src/plugins/transform-async-arrows-in-class/index.js
new file mode 100644
index 000000000..b05947771
--- /dev/null
+++ b/node_modules/@babel/preset-modules/src/plugins/transform-async-arrows-in-class/index.js
@@ -0,0 +1,35 @@
+/**
+ * Safari 10.3 had an issue where async arrow function expressions within any class method would throw.
+ * After an initial fix, any references to the instance via `this` within those methods would also throw.
+ * This is fixed by converting arrow functions in class methods into equivalent function expressions.
+ * @see https://bugs.webkit.org/show_bug.cgi?id=166879
+ *
+ * @example
+ * class X{ a(){ async () => {}; } } // throws
+ * class X{ a(){ async function() {}; } } // works
+ *
+ * @example
+ * class X{ a(){
+ * async () => this.a; // throws
+ * } }
+ * class X{ a(){
+ * var _this=this;
+ * async function() { return _this.a }; // works
+ * } }
+ */
+
+const OPTS = {
+ allowInsertArrow: false,
+ specCompliant: false,
+};
+
+export default ({ types: t }) => ({
+ name: "transform-async-arrows-in-class",
+ visitor: {
+ ArrowFunctionExpression(path) {
+ if (path.node.async && path.findParent(t.isClassMethod)) {
+ path.arrowFunctionToExpression(OPTS);
+ }
+ },
+ },
+});
diff --git a/node_modules/@babel/preset-modules/src/plugins/transform-edge-default-parameters/index.js b/node_modules/@babel/preset-modules/src/plugins/transform-edge-default-parameters/index.js
new file mode 100644
index 000000000..fff50f198
--- /dev/null
+++ b/node_modules/@babel/preset-modules/src/plugins/transform-edge-default-parameters/index.js
@@ -0,0 +1,29 @@
+/**
+ * Converts destructured parameters with default values to non-shorthand syntax.
+ * This fixes the only arguments-related bug in ES Modules-supporting browsers (Edge 16 & 17).
+ * Use this plugin instead of @babel/plugin-transform-parameters when targeting ES Modules.
+ */
+
+export default ({ types: t }) => {
+ const isArrowParent = p =>
+ p.parentKey === "params" &&
+ p.parentPath &&
+ t.isArrowFunctionExpression(p.parentPath);
+
+ return {
+ name: "transform-edge-default-parameters",
+ visitor: {
+ AssignmentPattern(path) {
+ const arrowArgParent = path.find(isArrowParent);
+ if (arrowArgParent && path.parent.shorthand) {
+ // In Babel 7+, there is no way to force non-shorthand properties.
+ path.parent.shorthand = false;
+ (path.parent.extra || {}).shorthand = false;
+
+ // So, to ensure non-shorthand, rename the local identifier so it no longer matches:
+ path.scope.rename(path.parent.key.name);
+ }
+ },
+ },
+ };
+};
diff --git a/node_modules/@babel/preset-modules/src/plugins/transform-edge-function-name/index.js b/node_modules/@babel/preset-modules/src/plugins/transform-edge-function-name/index.js
new file mode 100644
index 000000000..f6873283d
--- /dev/null
+++ b/node_modules/@babel/preset-modules/src/plugins/transform-edge-function-name/index.js
@@ -0,0 +1,31 @@
+/**
+ * Edge 16 & 17 do not infer function.name from variable assignment.
+ * All other `function.name` behavior works fine, so we can skip most of @babel/transform-function-name.
+ * @see https://kangax.github.io/compat-table/es6/#test-function_name_property_variables_(function)
+ *
+ * Note: contrary to various Github issues, Edge 16+ *does* correctly infer the name of Arrow Functions.
+ * The variable declarator name inference issue only affects function expressions, so that's all we fix here.
+ *
+ * A Note on Minification: Terser undoes this transform *by default* unless `keep_fnames` is set to true.
+ * There is by design - if Function.name is critical to your application, you must configure
+ * your minifier to preserve function names.
+ */
+
+export default ({ types: t }) => ({
+ name: "transform-edge-function-name",
+ visitor: {
+ FunctionExpression: {
+ exit(path) {
+ if (!path.node.id && t.isIdentifier(path.parent.id)) {
+ const id = t.cloneNode(path.parent.id);
+ const binding = path.scope.getBinding(id.name);
+ // if the binding gets reassigned anywhere, rename it
+ if (binding?.constantViolations.length) {
+ path.scope.rename(id.name);
+ }
+ path.node.id = id;
+ }
+ },
+ },
+ },
+});
diff --git a/node_modules/@babel/preset-modules/src/plugins/transform-jsx-spread/index.js b/node_modules/@babel/preset-modules/src/plugins/transform-jsx-spread/index.js
new file mode 100644
index 000000000..ef0152458
--- /dev/null
+++ b/node_modules/@babel/preset-modules/src/plugins/transform-jsx-spread/index.js
@@ -0,0 +1,111 @@
+import esutils from "esutils";
+
+/**
+ * Converts JSX Spread arguments into Object Spread, avoiding Babel's helper or Object.assign injection.
+ * Input:
+ *
+ * Output:
+ *
+ * ...which Babel converts to:
+ * h("div", { a: "1", ...b })
+ */
+export default ({ types: t }) => {
+ // converts a set of JSXAttributes to an Object.assign() call
+ function convertAttributesAssign(attributes) {
+ const args = [];
+ for (let i = 0, current; i < attributes.length; i++) {
+ const node = attributes[i];
+ if (t.isJSXSpreadAttribute(node)) {
+ // the first attribute is a spread, avoid copying all other attributes onto it
+ if (i === 0) {
+ args.push(t.objectExpression([]));
+ }
+ current = null;
+ args.push(node.argument);
+ } else {
+ const name = getAttributeName(node);
+ const value = getAttributeValue(node);
+ if (!current) {
+ current = t.objectExpression([]);
+ args.push(current);
+ }
+ current.properties.push(t.objectProperty(name, value));
+ }
+ }
+ return t.callExpression(
+ t.memberExpression(t.identifier("Object"), t.identifier("assign")),
+ args
+ );
+ }
+
+ // Converts a JSXAttribute to the equivalent ObjectExpression property
+ function convertAttributeSpread(node) {
+ if (t.isJSXSpreadAttribute(node)) {
+ return t.spreadElement(node.argument);
+ }
+
+ const name = getAttributeName(node);
+ const value = getAttributeValue(node);
+ return t.inherits(t.objectProperty(name, value), node);
+ }
+
+ // Convert a JSX attribute name to an Object expression property name
+ function getAttributeName(node) {
+ if (t.isJSXNamespacedName(node.name)) {
+ return t.stringLiteral(
+ node.name.namespace.name + ":" + node.name.name.name
+ );
+ }
+ if (esutils.keyword.isIdentifierNameES6(node.name.name)) {
+ return t.identifier(node.name.name);
+ }
+ return t.stringLiteral(node.name.name);
+ }
+
+ // Convert a JSX attribute value to a JavaScript expression value
+ function getAttributeValue(node) {
+ let value = node.value || t.booleanLiteral(true);
+
+ if (t.isJSXExpressionContainer(value)) {
+ value = value.expression;
+ } else if (t.isStringLiteral(value)) {
+ value.value = value.value.replace(/\n\s+/g, " ");
+
+ // "raw" JSXText should not be used from a StringLiteral because it needs to be escaped.
+ if (value.extra && value.extra.raw) {
+ delete value.extra.raw;
+ }
+ }
+
+ return value;
+ }
+
+ return {
+ name: "transform-jsx-spread",
+ visitor: {
+ JSXOpeningElement(path, state) {
+ const useSpread = state.opts.useSpread === true;
+ const hasSpread = path.node.attributes.some(attr =>
+ t.isJSXSpreadAttribute(attr)
+ );
+
+ // ignore JSX Elements without spread or with lone spread:
+ if (!hasSpread || path.node.attributes.length === 1) return;
+
+ if (useSpread) {
+ path.node.attributes = [
+ t.jsxSpreadAttribute(
+ t.objectExpression(
+ path.node.attributes.map(convertAttributeSpread)
+ )
+ ),
+ ];
+ } else {
+ path.node.attributes = [
+ t.jsxSpreadAttribute(convertAttributesAssign(path.node.attributes)),
+ ];
+ }
+ },
+ },
+ };
+};
diff --git a/node_modules/@babel/preset-modules/src/plugins/transform-safari-block-shadowing/index.js b/node_modules/@babel/preset-modules/src/plugins/transform-safari-block-shadowing/index.js
new file mode 100644
index 000000000..f509c6b6b
--- /dev/null
+++ b/node_modules/@babel/preset-modules/src/plugins/transform-safari-block-shadowing/index.js
@@ -0,0 +1,39 @@
+/**
+ * Fixes block-shadowed let/const bindings in Safari 10/11.
+ * https://kangax.github.io/compat-table/es6/#test-let_scope_shadow_resolution
+ */
+export default function({ types: t }) {
+ return {
+ name: "transform-safari-block-shadowing",
+ visitor: {
+ VariableDeclarator(path) {
+ // the issue only affects let and const bindings:
+ const kind = path.parent.kind;
+ if (kind !== "let" && kind !== "const") return;
+
+ // ignore non-block-scoped bindings:
+ const block = path.scope.block;
+ if (t.isFunction(block) || t.isProgram(block)) return;
+
+ const bindings = t.getOuterBindingIdentifiers(path.node.id);
+ for (const name of Object.keys(bindings)) {
+ let scope = path.scope;
+
+ // ignore parent bindings (note: impossible due to let/const?)
+ if (!scope.hasOwnBinding(name)) continue;
+
+ // check if shadowed within the nearest function/program boundary
+ while ((scope = scope.parent)) {
+ if (scope.hasOwnBinding(name)) {
+ path.scope.rename(name);
+ break;
+ }
+ if (t.isFunction(scope.block) || t.isProgram(scope.block)) {
+ break;
+ }
+ }
+ }
+ },
+ },
+ };
+}
diff --git a/node_modules/@babel/preset-modules/src/plugins/transform-safari-for-shadowing/index.js b/node_modules/@babel/preset-modules/src/plugins/transform-safari-for-shadowing/index.js
new file mode 100644
index 000000000..83b4eafdd
--- /dev/null
+++ b/node_modules/@babel/preset-modules/src/plugins/transform-safari-for-shadowing/index.js
@@ -0,0 +1,38 @@
+/**
+ * Safari ~11 has an issue where variable declarations in a For statement throw if they shadow parameters.
+ * This is fixed by renaming any declarations in the left/init part of a For* statement so they don't shadow.
+ * @see https://bugs.webkit.org/show_bug.cgi?id=171041
+ *
+ * @example
+ * e => { for (let e of []) e } // throws
+ * e => { for (let _e of []) _e } // works
+ */
+
+function handle(declaration) {
+ if (!declaration.isVariableDeclaration()) return;
+
+ const fn = declaration.getFunctionParent();
+ const { name } = declaration.node.declarations[0].id;
+
+ // check if there is a shadowed binding coming from a parameter
+ if (
+ fn &&
+ fn.scope.hasOwnBinding(name) &&
+ fn.scope.getOwnBinding(name).kind === "param"
+ ) {
+ declaration.scope.rename(name);
+ }
+}
+
+export default () => ({
+ name: "transform-safari-for-shadowing",
+ visitor: {
+ ForXStatement(path) {
+ handle(path.get("left"));
+ },
+
+ ForStatement(path) {
+ handle(path.get("init"));
+ },
+ },
+});
diff --git a/node_modules/@babel/preset-modules/src/plugins/transform-tagged-template-caching/index.js b/node_modules/@babel/preset-modules/src/plugins/transform-tagged-template-caching/index.js
new file mode 100644
index 000000000..65d03999f
--- /dev/null
+++ b/node_modules/@babel/preset-modules/src/plugins/transform-tagged-template-caching/index.js
@@ -0,0 +1,88 @@
+/**
+ * Converts destructured parameters with default values to non-shorthand syntax.
+ * This fixes the only Tagged Templates-related bug in ES Modules-supporting browsers (Safari 10 & 11).
+ * Use this plugin instead of `@babel/plugin-transform-template-literals` when targeting ES Modules.
+ *
+ * @example
+ * // Bug 1: Safari 10/11 doesn't reliably return the same Strings value.
+ * // The value changes depending on invocation and function optimization state.
+ * function f() { return Object`` }
+ * f() === new f() // false, should be true.
+ *
+ * @example
+ * // Bug 2: Safari 10/11 use the same cached strings value when the string parts are the same.
+ * // This behavior comes from an earlier version of the spec, and can cause tricky bugs.
+ * Object``===Object`` // true, should be false.
+ *
+ * Benchmarks: https://jsperf.com/compiled-tagged-template-performance
+ */
+export default ({ types: t }) => ({
+ name: "transform-tagged-template-caching",
+ visitor: {
+ TaggedTemplateExpression(path, state) {
+ // tagged templates we've already dealt with
+ let processed = state.get("processed");
+ if (!processed) {
+ processed = new WeakSet();
+ state.set("processed", processed);
+ }
+
+ if (processed.has(path.node)) return path.skip();
+
+ // Grab the expressions from the original tag.
+ // tag`a${'hello'}` // ['hello']
+ const expressions = path.node.quasi.expressions;
+
+ // Create an identity function helper:
+ // identity = t => t
+ let identity = state.get("identity");
+ if (!identity) {
+ identity = path.scope
+ .getProgramParent()
+ .generateDeclaredUidIdentifier("_");
+ state.set("identity", identity);
+ const binding = path.scope.getBinding(identity.name);
+ binding.path.get("init").replaceWith(
+ t.arrowFunctionExpression(
+ // re-use the helper identifier for compressability
+ [t.identifier("t")],
+ t.identifier("t")
+ )
+ );
+ }
+
+ // Use the identity function helper to get a reference to the template's Strings.
+ // We replace all expressions with `0` ensure Strings has the same shape.
+ // identity`a${0}`
+ const template = t.taggedTemplateExpression(
+ t.cloneNode(identity),
+ t.templateLiteral(
+ path.node.quasi.quasis,
+ expressions.map(() => t.numericLiteral(0))
+ )
+ );
+ processed.add(template);
+
+ // Install an inline cache at the callsite using the global variable:
+ // _t || (_t = identity`a${0}`)
+ const ident = path.scope
+ .getProgramParent()
+ .generateDeclaredUidIdentifier("t");
+ path.scope.getBinding(ident.name).path.parent.kind = "let";
+ const inlineCache = t.logicalExpression(
+ "||",
+ ident,
+ t.assignmentExpression("=", t.cloneNode(ident), template)
+ );
+
+ // The original tag function becomes a plain function call.
+ // The expressions omitted from the cached Strings tag are directly applied as arguments.
+ // tag(_t || (_t = Object`a${0}`), 'hello')
+ const node = t.callExpression(path.node.tag, [
+ inlineCache,
+ ...expressions,
+ ]);
+ path.replaceWith(node);
+ },
+ },
+});
diff --git a/node_modules/@babel/runtime/LICENSE b/node_modules/@babel/runtime/LICENSE
new file mode 100644
index 000000000..f31575ec7
--- /dev/null
+++ b/node_modules/@babel/runtime/LICENSE
@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/node_modules/@babel/runtime/README.md b/node_modules/@babel/runtime/README.md
new file mode 100644
index 000000000..be27e8347
--- /dev/null
+++ b/node_modules/@babel/runtime/README.md
@@ -0,0 +1,19 @@
+# @babel/runtime
+
+> babel's modular runtime helpers
+
+See our website [@babel/runtime](https://babeljs.io/docs/en/babel-runtime) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save @babel/runtime
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/runtime
+```
diff --git a/node_modules/@babel/runtime/helpers/AsyncGenerator.js b/node_modules/@babel/runtime/helpers/AsyncGenerator.js
new file mode 100644
index 000000000..e6a15a7c8
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/AsyncGenerator.js
@@ -0,0 +1,98 @@
+var AwaitValue = require("./AwaitValue.js");
+
+function AsyncGenerator(gen) {
+ var front, back;
+
+ function send(key, arg) {
+ return new Promise(function (resolve, reject) {
+ var request = {
+ key: key,
+ arg: arg,
+ resolve: resolve,
+ reject: reject,
+ next: null
+ };
+
+ if (back) {
+ back = back.next = request;
+ } else {
+ front = back = request;
+ resume(key, arg);
+ }
+ });
+ }
+
+ function resume(key, arg) {
+ try {
+ var result = gen[key](arg);
+ var value = result.value;
+ var wrappedAwait = value instanceof AwaitValue;
+ Promise.resolve(wrappedAwait ? value.wrapped : value).then(function (arg) {
+ if (wrappedAwait) {
+ resume(key === "return" ? "return" : "next", arg);
+ return;
+ }
+
+ settle(result.done ? "return" : "normal", arg);
+ }, function (err) {
+ resume("throw", err);
+ });
+ } catch (err) {
+ settle("throw", err);
+ }
+ }
+
+ function settle(type, value) {
+ switch (type) {
+ case "return":
+ front.resolve({
+ value: value,
+ done: true
+ });
+ break;
+
+ case "throw":
+ front.reject(value);
+ break;
+
+ default:
+ front.resolve({
+ value: value,
+ done: false
+ });
+ break;
+ }
+
+ front = front.next;
+
+ if (front) {
+ resume(front.key, front.arg);
+ } else {
+ back = null;
+ }
+ }
+
+ this._invoke = send;
+
+ if (typeof gen["return"] !== "function") {
+ this["return"] = undefined;
+ }
+}
+
+AsyncGenerator.prototype[typeof Symbol === "function" && Symbol.asyncIterator || "@@asyncIterator"] = function () {
+ return this;
+};
+
+AsyncGenerator.prototype.next = function (arg) {
+ return this._invoke("next", arg);
+};
+
+AsyncGenerator.prototype["throw"] = function (arg) {
+ return this._invoke("throw", arg);
+};
+
+AsyncGenerator.prototype["return"] = function (arg) {
+ return this._invoke("return", arg);
+};
+
+module.exports = AsyncGenerator, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/AwaitValue.js b/node_modules/@babel/runtime/helpers/AwaitValue.js
new file mode 100644
index 000000000..5ddee2e17
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/AwaitValue.js
@@ -0,0 +1,5 @@
+function _AwaitValue(value) {
+ this.wrapped = value;
+}
+
+module.exports = _AwaitValue, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/applyDecoratedDescriptor.js b/node_modules/@babel/runtime/helpers/applyDecoratedDescriptor.js
new file mode 100644
index 000000000..9080fd635
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/applyDecoratedDescriptor.js
@@ -0,0 +1,30 @@
+function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) {
+ var desc = {};
+ Object.keys(descriptor).forEach(function (key) {
+ desc[key] = descriptor[key];
+ });
+ desc.enumerable = !!desc.enumerable;
+ desc.configurable = !!desc.configurable;
+
+ if ('value' in desc || desc.initializer) {
+ desc.writable = true;
+ }
+
+ desc = decorators.slice().reverse().reduce(function (desc, decorator) {
+ return decorator(target, property, desc) || desc;
+ }, desc);
+
+ if (context && desc.initializer !== void 0) {
+ desc.value = desc.initializer ? desc.initializer.call(context) : void 0;
+ desc.initializer = undefined;
+ }
+
+ if (desc.initializer === void 0) {
+ Object.defineProperty(target, property, desc);
+ desc = null;
+ }
+
+ return desc;
+}
+
+module.exports = _applyDecoratedDescriptor, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/applyDecs.js b/node_modules/@babel/runtime/helpers/applyDecs.js
new file mode 100644
index 000000000..7a7a5e75e
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/applyDecs.js
@@ -0,0 +1,256 @@
+var _typeof = require("./typeof.js")["default"];
+
+function createMetadataMethodsForProperty(metadataMap, kind, property) {
+ return {
+ getMetadata: function getMetadata(key) {
+ if ("symbol" != _typeof(key)) throw new TypeError("Metadata keys must be symbols, received: " + key);
+ var metadataForKey = metadataMap[key];
+ if (void 0 !== metadataForKey) if (1 === kind) {
+ var pub = metadataForKey["public"];
+ if (void 0 !== pub) return pub[property];
+ } else if (2 === kind) {
+ var priv = metadataForKey["private"];
+ if (void 0 !== priv) return priv.get(property);
+ } else if (Object.hasOwnProperty.call(metadataForKey, "constructor")) return metadataForKey.constructor;
+ },
+ setMetadata: function setMetadata(key, value) {
+ if ("symbol" != _typeof(key)) throw new TypeError("Metadata keys must be symbols, received: " + key);
+ var metadataForKey = metadataMap[key];
+
+ if (void 0 === metadataForKey && (metadataForKey = metadataMap[key] = {}), 1 === kind) {
+ var pub = metadataForKey["public"];
+ void 0 === pub && (pub = metadataForKey["public"] = {}), pub[property] = value;
+ } else if (2 === kind) {
+ var priv = metadataForKey.priv;
+ void 0 === priv && (priv = metadataForKey["private"] = new Map()), priv.set(property, value);
+ } else metadataForKey.constructor = value;
+ }
+ };
+}
+
+function convertMetadataMapToFinal(obj, metadataMap) {
+ var parentMetadataMap = obj[Symbol.metadata || Symbol["for"]("Symbol.metadata")],
+ metadataKeys = Object.getOwnPropertySymbols(metadataMap);
+
+ if (0 !== metadataKeys.length) {
+ for (var i = 0; i < metadataKeys.length; i++) {
+ var key = metadataKeys[i],
+ metaForKey = metadataMap[key],
+ parentMetaForKey = parentMetadataMap ? parentMetadataMap[key] : null,
+ pub = metaForKey["public"],
+ parentPub = parentMetaForKey ? parentMetaForKey["public"] : null;
+ pub && parentPub && Object.setPrototypeOf(pub, parentPub);
+ var priv = metaForKey["private"];
+
+ if (priv) {
+ var privArr = Array.from(priv.values()),
+ parentPriv = parentMetaForKey ? parentMetaForKey["private"] : null;
+ parentPriv && (privArr = privArr.concat(parentPriv)), metaForKey["private"] = privArr;
+ }
+
+ parentMetaForKey && Object.setPrototypeOf(metaForKey, parentMetaForKey);
+ }
+
+ parentMetadataMap && Object.setPrototypeOf(metadataMap, parentMetadataMap), obj[Symbol.metadata || Symbol["for"]("Symbol.metadata")] = metadataMap;
+ }
+}
+
+function createAddInitializerMethod(initializers) {
+ return function (initializer) {
+ assertValidInitializer(initializer), initializers.push(initializer);
+ };
+}
+
+function memberDecCtx(base, name, desc, metadataMap, initializers, kind, isStatic, isPrivate) {
+ var kindStr;
+
+ switch (kind) {
+ case 1:
+ kindStr = "accessor";
+ break;
+
+ case 2:
+ kindStr = "method";
+ break;
+
+ case 3:
+ kindStr = "getter";
+ break;
+
+ case 4:
+ kindStr = "setter";
+ break;
+
+ default:
+ kindStr = "field";
+ }
+
+ var metadataKind,
+ metadataName,
+ ctx = {
+ kind: kindStr,
+ name: isPrivate ? "#" + name : name,
+ isStatic: isStatic,
+ isPrivate: isPrivate
+ };
+
+ if (0 !== kind && (ctx.addInitializer = createAddInitializerMethod(initializers)), isPrivate) {
+ metadataKind = 2, metadataName = Symbol(name);
+ var access = {};
+ 0 === kind ? (access.get = desc.get, access.set = desc.set) : 2 === kind ? access.get = function () {
+ return desc.value;
+ } : (1 !== kind && 3 !== kind || (access.get = function () {
+ return desc.get.call(this);
+ }), 1 !== kind && 4 !== kind || (access.set = function (v) {
+ desc.set.call(this, v);
+ })), ctx.access = access;
+ } else metadataKind = 1, metadataName = name;
+
+ return Object.assign(ctx, createMetadataMethodsForProperty(metadataMap, metadataKind, metadataName));
+}
+
+function assertValidInitializer(initializer) {
+ if ("function" != typeof initializer) throw new Error("initializers must be functions");
+}
+
+function assertValidReturnValue(kind, value) {
+ var type = _typeof(value);
+
+ if (1 === kind) {
+ if ("object" !== type || null === value) throw new Error("accessor decorators must return an object with get, set, or initializer properties or void 0");
+ } else if ("function" !== type) throw 0 === kind ? new Error("field decorators must return a initializer function or void 0") : new Error("method decorators must return a function or void 0");
+}
+
+function applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, metadataMap, initializers) {
+ var desc,
+ initializer,
+ value,
+ decs = decInfo[0];
+ isPrivate ? desc = 0 === kind || 1 === kind ? {
+ get: decInfo[3],
+ set: decInfo[4]
+ } : 3 === kind ? {
+ get: decInfo[3]
+ } : 4 === kind ? {
+ set: decInfo[3]
+ } : {
+ value: decInfo[3]
+ } : 0 !== kind && (desc = Object.getOwnPropertyDescriptor(base, name)), 1 === kind ? value = {
+ get: desc.get,
+ set: desc.set
+ } : 2 === kind ? value = desc.value : 3 === kind ? value = desc.get : 4 === kind && (value = desc.set);
+ var newValue,
+ get,
+ set,
+ ctx = memberDecCtx(base, name, desc, metadataMap, initializers, kind, isStatic, isPrivate);
+ if ("function" == typeof decs) void 0 !== (newValue = decs(value, ctx)) && (assertValidReturnValue(kind, newValue), 0 === kind ? initializer = newValue : 1 === kind ? (initializer = newValue.initializer, get = newValue.get || value.get, set = newValue.set || value.set, value = {
+ get: get,
+ set: set
+ }) : value = newValue);else for (var i = decs.length - 1; i >= 0; i--) {
+ var newInit;
+ if (void 0 !== (newValue = (0, decs[i])(value, ctx))) assertValidReturnValue(kind, newValue), 0 === kind ? newInit = newValue : 1 === kind ? (newInit = newValue.initializer, get = newValue.get || value.get, set = newValue.set || value.set, value = {
+ get: get,
+ set: set
+ }) : value = newValue, void 0 !== newInit && (void 0 === initializer ? initializer = newInit : "function" == typeof initializer ? initializer = [initializer, newInit] : initializer.push(newInit));
+ }
+
+ if (0 === kind || 1 === kind) {
+ if (void 0 === initializer) initializer = function initializer(instance, init) {
+ return init;
+ };else if ("function" != typeof initializer) {
+ var ownInitializers = initializer;
+
+ initializer = function initializer(instance, init) {
+ for (var value = init, i = 0; i < ownInitializers.length; i++) {
+ value = ownInitializers[i].call(instance, value);
+ }
+
+ return value;
+ };
+ } else {
+ var originalInitializer = initializer;
+
+ initializer = function initializer(instance, init) {
+ return originalInitializer.call(instance, init);
+ };
+ }
+ ret.push(initializer);
+ }
+
+ 0 !== kind && (1 === kind ? (desc.get = value.get, desc.set = value.set) : 2 === kind ? desc.value = value : 3 === kind ? desc.get = value : 4 === kind && (desc.set = value), isPrivate ? 1 === kind ? (ret.push(function (instance, args) {
+ return value.get.call(instance, args);
+ }), ret.push(function (instance, args) {
+ return value.set.call(instance, args);
+ })) : 2 === kind ? ret.push(value) : ret.push(function (instance, args) {
+ return value.call(instance, args);
+ }) : Object.defineProperty(base, name, desc));
+}
+
+function applyMemberDecs(ret, Class, protoMetadataMap, staticMetadataMap, decInfos) {
+ for (var protoInitializers = [], staticInitializers = [], existingProtoNonFields = new Map(), existingStaticNonFields = new Map(), i = 0; i < decInfos.length; i++) {
+ var decInfo = decInfos[i];
+
+ if (Array.isArray(decInfo)) {
+ var base,
+ metadataMap,
+ initializers,
+ kind = decInfo[1],
+ name = decInfo[2],
+ isPrivate = decInfo.length > 3,
+ isStatic = kind >= 5;
+
+ if (isStatic ? (base = Class, metadataMap = staticMetadataMap, kind -= 5, initializers = staticInitializers) : (base = Class.prototype, metadataMap = protoMetadataMap, initializers = protoInitializers), 0 !== kind && !isPrivate) {
+ var existingNonFields = isStatic ? existingStaticNonFields : existingProtoNonFields,
+ existingKind = existingNonFields.get(name) || 0;
+ if (!0 === existingKind || 3 === existingKind && 4 !== kind || 4 === existingKind && 3 !== kind) throw new Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + name);
+ !existingKind && kind > 2 ? existingNonFields.set(name, kind) : existingNonFields.set(name, !0);
+ }
+
+ applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, metadataMap, initializers);
+ }
+ }
+
+ protoInitializers.length > 0 && pushInitializers(ret, protoInitializers), staticInitializers.length > 0 && pushInitializers(ret, staticInitializers);
+}
+
+function pushInitializers(ret, initializers) {
+ initializers.length > 0 ? (initializers = initializers.slice(), ret.push(function (instance) {
+ for (var i = 0; i < initializers.length; i++) {
+ initializers[i].call(instance, instance);
+ }
+
+ return instance;
+ })) : ret.push(function (instance) {
+ return instance;
+ });
+}
+
+function applyClassDecs(ret, targetClass, metadataMap, classDecs) {
+ for (var initializers = [], newClass = targetClass, name = targetClass.name, ctx = Object.assign({
+ kind: "class",
+ name: name,
+ addInitializer: createAddInitializerMethod(initializers)
+ }, createMetadataMethodsForProperty(metadataMap, 0, name)), i = classDecs.length - 1; i >= 0; i--) {
+ newClass = classDecs[i](newClass, ctx) || newClass;
+ }
+
+ ret.push(newClass), initializers.length > 0 ? ret.push(function () {
+ for (var i = 0; i < initializers.length; i++) {
+ initializers[i].call(newClass, newClass);
+ }
+ }) : ret.push(function () {});
+}
+
+function applyDecs(targetClass, memberDecs, classDecs) {
+ var ret = [],
+ staticMetadataMap = {};
+
+ if (memberDecs) {
+ var protoMetadataMap = {};
+ applyMemberDecs(ret, targetClass, protoMetadataMap, staticMetadataMap, memberDecs), convertMetadataMapToFinal(targetClass.prototype, protoMetadataMap);
+ }
+
+ return classDecs && applyClassDecs(ret, targetClass, staticMetadataMap, classDecs), convertMetadataMapToFinal(targetClass, staticMetadataMap), ret;
+}
+
+module.exports = applyDecs, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/arrayLikeToArray.js b/node_modules/@babel/runtime/helpers/arrayLikeToArray.js
new file mode 100644
index 000000000..465974f1e
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/arrayLikeToArray.js
@@ -0,0 +1,11 @@
+function _arrayLikeToArray(arr, len) {
+ if (len == null || len > arr.length) len = arr.length;
+
+ for (var i = 0, arr2 = new Array(len); i < len; i++) {
+ arr2[i] = arr[i];
+ }
+
+ return arr2;
+}
+
+module.exports = _arrayLikeToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/arrayWithHoles.js b/node_modules/@babel/runtime/helpers/arrayWithHoles.js
new file mode 100644
index 000000000..b5680a0e4
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/arrayWithHoles.js
@@ -0,0 +1,5 @@
+function _arrayWithHoles(arr) {
+ if (Array.isArray(arr)) return arr;
+}
+
+module.exports = _arrayWithHoles, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/arrayWithoutHoles.js b/node_modules/@babel/runtime/helpers/arrayWithoutHoles.js
new file mode 100644
index 000000000..30bf377fd
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/arrayWithoutHoles.js
@@ -0,0 +1,7 @@
+var arrayLikeToArray = require("./arrayLikeToArray.js");
+
+function _arrayWithoutHoles(arr) {
+ if (Array.isArray(arr)) return arrayLikeToArray(arr);
+}
+
+module.exports = _arrayWithoutHoles, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/assertThisInitialized.js b/node_modules/@babel/runtime/helpers/assertThisInitialized.js
new file mode 100644
index 000000000..70ea85579
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/assertThisInitialized.js
@@ -0,0 +1,9 @@
+function _assertThisInitialized(self) {
+ if (self === void 0) {
+ throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+ }
+
+ return self;
+}
+
+module.exports = _assertThisInitialized, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/asyncGeneratorDelegate.js b/node_modules/@babel/runtime/helpers/asyncGeneratorDelegate.js
new file mode 100644
index 000000000..cf7d4801c
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/asyncGeneratorDelegate.js
@@ -0,0 +1,56 @@
+function _asyncGeneratorDelegate(inner, awaitWrap) {
+ var iter = {},
+ waiting = false;
+
+ function pump(key, value) {
+ waiting = true;
+ value = new Promise(function (resolve) {
+ resolve(inner[key](value));
+ });
+ return {
+ done: false,
+ value: awaitWrap(value)
+ };
+ }
+
+ ;
+
+ iter[typeof Symbol !== "undefined" && Symbol.iterator || "@@iterator"] = function () {
+ return this;
+ };
+
+ iter.next = function (value) {
+ if (waiting) {
+ waiting = false;
+ return value;
+ }
+
+ return pump("next", value);
+ };
+
+ if (typeof inner["throw"] === "function") {
+ iter["throw"] = function (value) {
+ if (waiting) {
+ waiting = false;
+ throw value;
+ }
+
+ return pump("throw", value);
+ };
+ }
+
+ if (typeof inner["return"] === "function") {
+ iter["return"] = function (value) {
+ if (waiting) {
+ waiting = false;
+ return value;
+ }
+
+ return pump("return", value);
+ };
+ }
+
+ return iter;
+}
+
+module.exports = _asyncGeneratorDelegate, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/asyncIterator.js b/node_modules/@babel/runtime/helpers/asyncIterator.js
new file mode 100644
index 000000000..d8e11f01b
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/asyncIterator.js
@@ -0,0 +1,50 @@
+function _asyncIterator(iterable) {
+ var method,
+ async,
+ sync,
+ retry = 2;
+
+ for ("undefined" != typeof Symbol && (async = Symbol.asyncIterator, sync = Symbol.iterator); retry--;) {
+ if (async && null != (method = iterable[async])) return method.call(iterable);
+ if (sync && null != (method = iterable[sync])) return new AsyncFromSyncIterator(method.call(iterable));
+ async = "@@asyncIterator", sync = "@@iterator";
+ }
+
+ throw new TypeError("Object is not async iterable");
+}
+
+function AsyncFromSyncIterator(s) {
+ function AsyncFromSyncIteratorContinuation(r) {
+ if (Object(r) !== r) return Promise.reject(new TypeError(r + " is not an object."));
+ var done = r.done;
+ return Promise.resolve(r.value).then(function (value) {
+ return {
+ value: value,
+ done: done
+ };
+ });
+ }
+
+ return AsyncFromSyncIterator = function AsyncFromSyncIterator(s) {
+ this.s = s, this.n = s.next;
+ }, AsyncFromSyncIterator.prototype = {
+ s: null,
+ n: null,
+ next: function next() {
+ return AsyncFromSyncIteratorContinuation(this.n.apply(this.s, arguments));
+ },
+ "return": function _return(value) {
+ var ret = this.s["return"];
+ return void 0 === ret ? Promise.resolve({
+ value: value,
+ done: !0
+ }) : AsyncFromSyncIteratorContinuation(ret.apply(this.s, arguments));
+ },
+ "throw": function _throw(value) {
+ var thr = this.s["return"];
+ return void 0 === thr ? Promise.reject(value) : AsyncFromSyncIteratorContinuation(thr.apply(this.s, arguments));
+ }
+ }, new AsyncFromSyncIterator(s);
+}
+
+module.exports = _asyncIterator, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/asyncToGenerator.js b/node_modules/@babel/runtime/helpers/asyncToGenerator.js
new file mode 100644
index 000000000..becd16303
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/asyncToGenerator.js
@@ -0,0 +1,37 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+ try {
+ var info = gen[key](arg);
+ var value = info.value;
+ } catch (error) {
+ reject(error);
+ return;
+ }
+
+ if (info.done) {
+ resolve(value);
+ } else {
+ Promise.resolve(value).then(_next, _throw);
+ }
+}
+
+function _asyncToGenerator(fn) {
+ return function () {
+ var self = this,
+ args = arguments;
+ return new Promise(function (resolve, reject) {
+ var gen = fn.apply(self, args);
+
+ function _next(value) {
+ asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+ }
+
+ function _throw(err) {
+ asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+ }
+
+ _next(undefined);
+ });
+ };
+}
+
+module.exports = _asyncToGenerator, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/awaitAsyncGenerator.js b/node_modules/@babel/runtime/helpers/awaitAsyncGenerator.js
new file mode 100644
index 000000000..f0f30ed77
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/awaitAsyncGenerator.js
@@ -0,0 +1,7 @@
+var AwaitValue = require("./AwaitValue.js");
+
+function _awaitAsyncGenerator(value) {
+ return new AwaitValue(value);
+}
+
+module.exports = _awaitAsyncGenerator, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/checkPrivateRedeclaration.js b/node_modules/@babel/runtime/helpers/checkPrivateRedeclaration.js
new file mode 100644
index 000000000..6cd0fcbb4
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/checkPrivateRedeclaration.js
@@ -0,0 +1,7 @@
+function _checkPrivateRedeclaration(obj, privateCollection) {
+ if (privateCollection.has(obj)) {
+ throw new TypeError("Cannot initialize the same private elements twice on an object");
+ }
+}
+
+module.exports = _checkPrivateRedeclaration, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/classApplyDescriptorDestructureSet.js b/node_modules/@babel/runtime/helpers/classApplyDescriptorDestructureSet.js
new file mode 100644
index 000000000..ea1c860d6
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/classApplyDescriptorDestructureSet.js
@@ -0,0 +1,22 @@
+function _classApplyDescriptorDestructureSet(receiver, descriptor) {
+ if (descriptor.set) {
+ if (!("__destrObj" in descriptor)) {
+ descriptor.__destrObj = {
+ set value(v) {
+ descriptor.set.call(receiver, v);
+ }
+
+ };
+ }
+
+ return descriptor.__destrObj;
+ } else {
+ if (!descriptor.writable) {
+ throw new TypeError("attempted to set read only private field");
+ }
+
+ return descriptor;
+ }
+}
+
+module.exports = _classApplyDescriptorDestructureSet, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/classApplyDescriptorGet.js b/node_modules/@babel/runtime/helpers/classApplyDescriptorGet.js
new file mode 100644
index 000000000..b9d0e9496
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/classApplyDescriptorGet.js
@@ -0,0 +1,9 @@
+function _classApplyDescriptorGet(receiver, descriptor) {
+ if (descriptor.get) {
+ return descriptor.get.call(receiver);
+ }
+
+ return descriptor.value;
+}
+
+module.exports = _classApplyDescriptorGet, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/classApplyDescriptorSet.js b/node_modules/@babel/runtime/helpers/classApplyDescriptorSet.js
new file mode 100644
index 000000000..9824b5c5a
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/classApplyDescriptorSet.js
@@ -0,0 +1,13 @@
+function _classApplyDescriptorSet(receiver, descriptor, value) {
+ if (descriptor.set) {
+ descriptor.set.call(receiver, value);
+ } else {
+ if (!descriptor.writable) {
+ throw new TypeError("attempted to set read only private field");
+ }
+
+ descriptor.value = value;
+ }
+}
+
+module.exports = _classApplyDescriptorSet, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/classCallCheck.js b/node_modules/@babel/runtime/helpers/classCallCheck.js
new file mode 100644
index 000000000..141884533
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/classCallCheck.js
@@ -0,0 +1,7 @@
+function _classCallCheck(instance, Constructor) {
+ if (!(instance instanceof Constructor)) {
+ throw new TypeError("Cannot call a class as a function");
+ }
+}
+
+module.exports = _classCallCheck, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/classCheckPrivateStaticAccess.js b/node_modules/@babel/runtime/helpers/classCheckPrivateStaticAccess.js
new file mode 100644
index 000000000..7f5213bc6
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/classCheckPrivateStaticAccess.js
@@ -0,0 +1,7 @@
+function _classCheckPrivateStaticAccess(receiver, classConstructor) {
+ if (receiver !== classConstructor) {
+ throw new TypeError("Private static access of wrong provenance");
+ }
+}
+
+module.exports = _classCheckPrivateStaticAccess, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/classCheckPrivateStaticFieldDescriptor.js b/node_modules/@babel/runtime/helpers/classCheckPrivateStaticFieldDescriptor.js
new file mode 100644
index 000000000..87ec4ea8d
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/classCheckPrivateStaticFieldDescriptor.js
@@ -0,0 +1,7 @@
+function _classCheckPrivateStaticFieldDescriptor(descriptor, action) {
+ if (descriptor === undefined) {
+ throw new TypeError("attempted to " + action + " private static field before its declaration");
+ }
+}
+
+module.exports = _classCheckPrivateStaticFieldDescriptor, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/classExtractFieldDescriptor.js b/node_modules/@babel/runtime/helpers/classExtractFieldDescriptor.js
new file mode 100644
index 000000000..5c422bfcd
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/classExtractFieldDescriptor.js
@@ -0,0 +1,9 @@
+function _classExtractFieldDescriptor(receiver, privateMap, action) {
+ if (!privateMap.has(receiver)) {
+ throw new TypeError("attempted to " + action + " private field on non-instance");
+ }
+
+ return privateMap.get(receiver);
+}
+
+module.exports = _classExtractFieldDescriptor, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/classNameTDZError.js b/node_modules/@babel/runtime/helpers/classNameTDZError.js
new file mode 100644
index 000000000..9a48c7036
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/classNameTDZError.js
@@ -0,0 +1,5 @@
+function _classNameTDZError(name) {
+ throw new Error("Class \"" + name + "\" cannot be referenced in computed property keys.");
+}
+
+module.exports = _classNameTDZError, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/classPrivateFieldDestructureSet.js b/node_modules/@babel/runtime/helpers/classPrivateFieldDestructureSet.js
new file mode 100644
index 000000000..07abfe5f3
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/classPrivateFieldDestructureSet.js
@@ -0,0 +1,10 @@
+var classApplyDescriptorDestructureSet = require("./classApplyDescriptorDestructureSet.js");
+
+var classExtractFieldDescriptor = require("./classExtractFieldDescriptor.js");
+
+function _classPrivateFieldDestructureSet(receiver, privateMap) {
+ var descriptor = classExtractFieldDescriptor(receiver, privateMap, "set");
+ return classApplyDescriptorDestructureSet(receiver, descriptor);
+}
+
+module.exports = _classPrivateFieldDestructureSet, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/classPrivateFieldGet.js b/node_modules/@babel/runtime/helpers/classPrivateFieldGet.js
new file mode 100644
index 000000000..470ded71a
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/classPrivateFieldGet.js
@@ -0,0 +1,10 @@
+var classApplyDescriptorGet = require("./classApplyDescriptorGet.js");
+
+var classExtractFieldDescriptor = require("./classExtractFieldDescriptor.js");
+
+function _classPrivateFieldGet(receiver, privateMap) {
+ var descriptor = classExtractFieldDescriptor(receiver, privateMap, "get");
+ return classApplyDescriptorGet(receiver, descriptor);
+}
+
+module.exports = _classPrivateFieldGet, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/classPrivateFieldInitSpec.js b/node_modules/@babel/runtime/helpers/classPrivateFieldInitSpec.js
new file mode 100644
index 000000000..a6243c27d
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/classPrivateFieldInitSpec.js
@@ -0,0 +1,8 @@
+var checkPrivateRedeclaration = require("./checkPrivateRedeclaration.js");
+
+function _classPrivateFieldInitSpec(obj, privateMap, value) {
+ checkPrivateRedeclaration(obj, privateMap);
+ privateMap.set(obj, value);
+}
+
+module.exports = _classPrivateFieldInitSpec, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/classPrivateFieldLooseBase.js b/node_modules/@babel/runtime/helpers/classPrivateFieldLooseBase.js
new file mode 100644
index 000000000..571109ff2
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/classPrivateFieldLooseBase.js
@@ -0,0 +1,9 @@
+function _classPrivateFieldBase(receiver, privateKey) {
+ if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) {
+ throw new TypeError("attempted to use private field on non-instance");
+ }
+
+ return receiver;
+}
+
+module.exports = _classPrivateFieldBase, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/classPrivateFieldLooseKey.js b/node_modules/@babel/runtime/helpers/classPrivateFieldLooseKey.js
new file mode 100644
index 000000000..b05e19400
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/classPrivateFieldLooseKey.js
@@ -0,0 +1,7 @@
+var id = 0;
+
+function _classPrivateFieldKey(name) {
+ return "__private_" + id++ + "_" + name;
+}
+
+module.exports = _classPrivateFieldKey, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/classPrivateFieldSet.js b/node_modules/@babel/runtime/helpers/classPrivateFieldSet.js
new file mode 100644
index 000000000..f8ab84208
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/classPrivateFieldSet.js
@@ -0,0 +1,11 @@
+var classApplyDescriptorSet = require("./classApplyDescriptorSet.js");
+
+var classExtractFieldDescriptor = require("./classExtractFieldDescriptor.js");
+
+function _classPrivateFieldSet(receiver, privateMap, value) {
+ var descriptor = classExtractFieldDescriptor(receiver, privateMap, "set");
+ classApplyDescriptorSet(receiver, descriptor, value);
+ return value;
+}
+
+module.exports = _classPrivateFieldSet, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/classPrivateMethodGet.js b/node_modules/@babel/runtime/helpers/classPrivateMethodGet.js
new file mode 100644
index 000000000..540a1f3e7
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/classPrivateMethodGet.js
@@ -0,0 +1,9 @@
+function _classPrivateMethodGet(receiver, privateSet, fn) {
+ if (!privateSet.has(receiver)) {
+ throw new TypeError("attempted to get private field on non-instance");
+ }
+
+ return fn;
+}
+
+module.exports = _classPrivateMethodGet, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/classPrivateMethodInitSpec.js b/node_modules/@babel/runtime/helpers/classPrivateMethodInitSpec.js
new file mode 100644
index 000000000..6c4df76e0
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/classPrivateMethodInitSpec.js
@@ -0,0 +1,8 @@
+var checkPrivateRedeclaration = require("./checkPrivateRedeclaration.js");
+
+function _classPrivateMethodInitSpec(obj, privateSet) {
+ checkPrivateRedeclaration(obj, privateSet);
+ privateSet.add(obj);
+}
+
+module.exports = _classPrivateMethodInitSpec, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/classPrivateMethodSet.js b/node_modules/@babel/runtime/helpers/classPrivateMethodSet.js
new file mode 100644
index 000000000..226789d54
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/classPrivateMethodSet.js
@@ -0,0 +1,5 @@
+function _classPrivateMethodSet() {
+ throw new TypeError("attempted to reassign private method");
+}
+
+module.exports = _classPrivateMethodSet, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/classStaticPrivateFieldDestructureSet.js b/node_modules/@babel/runtime/helpers/classStaticPrivateFieldDestructureSet.js
new file mode 100644
index 000000000..120c74d81
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/classStaticPrivateFieldDestructureSet.js
@@ -0,0 +1,13 @@
+var classApplyDescriptorDestructureSet = require("./classApplyDescriptorDestructureSet.js");
+
+var classCheckPrivateStaticAccess = require("./classCheckPrivateStaticAccess.js");
+
+var classCheckPrivateStaticFieldDescriptor = require("./classCheckPrivateStaticFieldDescriptor.js");
+
+function _classStaticPrivateFieldDestructureSet(receiver, classConstructor, descriptor) {
+ classCheckPrivateStaticAccess(receiver, classConstructor);
+ classCheckPrivateStaticFieldDescriptor(descriptor, "set");
+ return classApplyDescriptorDestructureSet(receiver, descriptor);
+}
+
+module.exports = _classStaticPrivateFieldDestructureSet, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/classStaticPrivateFieldSpecGet.js b/node_modules/@babel/runtime/helpers/classStaticPrivateFieldSpecGet.js
new file mode 100644
index 000000000..d7201c336
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/classStaticPrivateFieldSpecGet.js
@@ -0,0 +1,13 @@
+var classApplyDescriptorGet = require("./classApplyDescriptorGet.js");
+
+var classCheckPrivateStaticAccess = require("./classCheckPrivateStaticAccess.js");
+
+var classCheckPrivateStaticFieldDescriptor = require("./classCheckPrivateStaticFieldDescriptor.js");
+
+function _classStaticPrivateFieldSpecGet(receiver, classConstructor, descriptor) {
+ classCheckPrivateStaticAccess(receiver, classConstructor);
+ classCheckPrivateStaticFieldDescriptor(descriptor, "get");
+ return classApplyDescriptorGet(receiver, descriptor);
+}
+
+module.exports = _classStaticPrivateFieldSpecGet, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/classStaticPrivateFieldSpecSet.js b/node_modules/@babel/runtime/helpers/classStaticPrivateFieldSpecSet.js
new file mode 100644
index 000000000..2aa13ef98
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/classStaticPrivateFieldSpecSet.js
@@ -0,0 +1,14 @@
+var classApplyDescriptorSet = require("./classApplyDescriptorSet.js");
+
+var classCheckPrivateStaticAccess = require("./classCheckPrivateStaticAccess.js");
+
+var classCheckPrivateStaticFieldDescriptor = require("./classCheckPrivateStaticFieldDescriptor.js");
+
+function _classStaticPrivateFieldSpecSet(receiver, classConstructor, descriptor, value) {
+ classCheckPrivateStaticAccess(receiver, classConstructor);
+ classCheckPrivateStaticFieldDescriptor(descriptor, "set");
+ classApplyDescriptorSet(receiver, descriptor, value);
+ return value;
+}
+
+module.exports = _classStaticPrivateFieldSpecSet, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/classStaticPrivateMethodGet.js b/node_modules/@babel/runtime/helpers/classStaticPrivateMethodGet.js
new file mode 100644
index 000000000..d77c84227
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/classStaticPrivateMethodGet.js
@@ -0,0 +1,8 @@
+var classCheckPrivateStaticAccess = require("./classCheckPrivateStaticAccess.js");
+
+function _classStaticPrivateMethodGet(receiver, classConstructor, method) {
+ classCheckPrivateStaticAccess(receiver, classConstructor);
+ return method;
+}
+
+module.exports = _classStaticPrivateMethodGet, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/classStaticPrivateMethodSet.js b/node_modules/@babel/runtime/helpers/classStaticPrivateMethodSet.js
new file mode 100644
index 000000000..2e1c83fdc
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/classStaticPrivateMethodSet.js
@@ -0,0 +1,5 @@
+function _classStaticPrivateMethodSet() {
+ throw new TypeError("attempted to set read only static private field");
+}
+
+module.exports = _classStaticPrivateMethodSet, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/construct.js b/node_modules/@babel/runtime/helpers/construct.js
new file mode 100644
index 000000000..c2518afc9
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/construct.js
@@ -0,0 +1,22 @@
+var setPrototypeOf = require("./setPrototypeOf.js");
+
+var isNativeReflectConstruct = require("./isNativeReflectConstruct.js");
+
+function _construct(Parent, args, Class) {
+ if (isNativeReflectConstruct()) {
+ module.exports = _construct = Reflect.construct, module.exports.__esModule = true, module.exports["default"] = module.exports;
+ } else {
+ module.exports = _construct = function _construct(Parent, args, Class) {
+ var a = [null];
+ a.push.apply(a, args);
+ var Constructor = Function.bind.apply(Parent, a);
+ var instance = new Constructor();
+ if (Class) setPrototypeOf(instance, Class.prototype);
+ return instance;
+ }, module.exports.__esModule = true, module.exports["default"] = module.exports;
+ }
+
+ return _construct.apply(null, arguments);
+}
+
+module.exports = _construct, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/createClass.js b/node_modules/@babel/runtime/helpers/createClass.js
new file mode 100644
index 000000000..4273e7a1b
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/createClass.js
@@ -0,0 +1,20 @@
+function _defineProperties(target, props) {
+ for (var i = 0; i < props.length; i++) {
+ var descriptor = props[i];
+ descriptor.enumerable = descriptor.enumerable || false;
+ descriptor.configurable = true;
+ if ("value" in descriptor) descriptor.writable = true;
+ Object.defineProperty(target, descriptor.key, descriptor);
+ }
+}
+
+function _createClass(Constructor, protoProps, staticProps) {
+ if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+ if (staticProps) _defineProperties(Constructor, staticProps);
+ Object.defineProperty(Constructor, "prototype", {
+ writable: false
+ });
+ return Constructor;
+}
+
+module.exports = _createClass, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/createForOfIteratorHelper.js b/node_modules/@babel/runtime/helpers/createForOfIteratorHelper.js
new file mode 100644
index 000000000..0835893b6
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/createForOfIteratorHelper.js
@@ -0,0 +1,60 @@
+var unsupportedIterableToArray = require("./unsupportedIterableToArray.js");
+
+function _createForOfIteratorHelper(o, allowArrayLike) {
+ var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+
+ if (!it) {
+ if (Array.isArray(o) || (it = unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+ if (it) o = it;
+ var i = 0;
+
+ var F = function F() {};
+
+ return {
+ s: F,
+ n: function n() {
+ if (i >= o.length) return {
+ done: true
+ };
+ return {
+ done: false,
+ value: o[i++]
+ };
+ },
+ e: function e(_e) {
+ throw _e;
+ },
+ f: F
+ };
+ }
+
+ throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+ }
+
+ var normalCompletion = true,
+ didErr = false,
+ err;
+ return {
+ s: function s() {
+ it = it.call(o);
+ },
+ n: function n() {
+ var step = it.next();
+ normalCompletion = step.done;
+ return step;
+ },
+ e: function e(_e2) {
+ didErr = true;
+ err = _e2;
+ },
+ f: function f() {
+ try {
+ if (!normalCompletion && it["return"] != null) it["return"]();
+ } finally {
+ if (didErr) throw err;
+ }
+ }
+ };
+}
+
+module.exports = _createForOfIteratorHelper, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/createForOfIteratorHelperLoose.js b/node_modules/@babel/runtime/helpers/createForOfIteratorHelperLoose.js
new file mode 100644
index 000000000..65d3bc9eb
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/createForOfIteratorHelperLoose.js
@@ -0,0 +1,24 @@
+var unsupportedIterableToArray = require("./unsupportedIterableToArray.js");
+
+function _createForOfIteratorHelperLoose(o, allowArrayLike) {
+ var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+ if (it) return (it = it.call(o)).next.bind(it);
+
+ if (Array.isArray(o) || (it = unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+ if (it) o = it;
+ var i = 0;
+ return function () {
+ if (i >= o.length) return {
+ done: true
+ };
+ return {
+ done: false,
+ value: o[i++]
+ };
+ };
+ }
+
+ throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+
+module.exports = _createForOfIteratorHelperLoose, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/createSuper.js b/node_modules/@babel/runtime/helpers/createSuper.js
new file mode 100644
index 000000000..624728bbe
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/createSuper.js
@@ -0,0 +1,24 @@
+var getPrototypeOf = require("./getPrototypeOf.js");
+
+var isNativeReflectConstruct = require("./isNativeReflectConstruct.js");
+
+var possibleConstructorReturn = require("./possibleConstructorReturn.js");
+
+function _createSuper(Derived) {
+ var hasNativeReflectConstruct = isNativeReflectConstruct();
+ return function _createSuperInternal() {
+ var Super = getPrototypeOf(Derived),
+ result;
+
+ if (hasNativeReflectConstruct) {
+ var NewTarget = getPrototypeOf(this).constructor;
+ result = Reflect.construct(Super, arguments, NewTarget);
+ } else {
+ result = Super.apply(this, arguments);
+ }
+
+ return possibleConstructorReturn(this, result);
+ };
+}
+
+module.exports = _createSuper, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/decorate.js b/node_modules/@babel/runtime/helpers/decorate.js
new file mode 100644
index 000000000..3bd35e7d0
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/decorate.js
@@ -0,0 +1,400 @@
+var toArray = require("./toArray.js");
+
+var toPropertyKey = require("./toPropertyKey.js");
+
+function _decorate(decorators, factory, superClass, mixins) {
+ var api = _getDecoratorsApi();
+
+ if (mixins) {
+ for (var i = 0; i < mixins.length; i++) {
+ api = mixins[i](api);
+ }
+ }
+
+ var r = factory(function initialize(O) {
+ api.initializeInstanceElements(O, decorated.elements);
+ }, superClass);
+ var decorated = api.decorateClass(_coalesceClassElements(r.d.map(_createElementDescriptor)), decorators);
+ api.initializeClassElements(r.F, decorated.elements);
+ return api.runClassFinishers(r.F, decorated.finishers);
+}
+
+function _getDecoratorsApi() {
+ _getDecoratorsApi = function _getDecoratorsApi() {
+ return api;
+ };
+
+ var api = {
+ elementsDefinitionOrder: [["method"], ["field"]],
+ initializeInstanceElements: function initializeInstanceElements(O, elements) {
+ ["method", "field"].forEach(function (kind) {
+ elements.forEach(function (element) {
+ if (element.kind === kind && element.placement === "own") {
+ this.defineClassElement(O, element);
+ }
+ }, this);
+ }, this);
+ },
+ initializeClassElements: function initializeClassElements(F, elements) {
+ var proto = F.prototype;
+ ["method", "field"].forEach(function (kind) {
+ elements.forEach(function (element) {
+ var placement = element.placement;
+
+ if (element.kind === kind && (placement === "static" || placement === "prototype")) {
+ var receiver = placement === "static" ? F : proto;
+ this.defineClassElement(receiver, element);
+ }
+ }, this);
+ }, this);
+ },
+ defineClassElement: function defineClassElement(receiver, element) {
+ var descriptor = element.descriptor;
+
+ if (element.kind === "field") {
+ var initializer = element.initializer;
+ descriptor = {
+ enumerable: descriptor.enumerable,
+ writable: descriptor.writable,
+ configurable: descriptor.configurable,
+ value: initializer === void 0 ? void 0 : initializer.call(receiver)
+ };
+ }
+
+ Object.defineProperty(receiver, element.key, descriptor);
+ },
+ decorateClass: function decorateClass(elements, decorators) {
+ var newElements = [];
+ var finishers = [];
+ var placements = {
+ "static": [],
+ prototype: [],
+ own: []
+ };
+ elements.forEach(function (element) {
+ this.addElementPlacement(element, placements);
+ }, this);
+ elements.forEach(function (element) {
+ if (!_hasDecorators(element)) return newElements.push(element);
+ var elementFinishersExtras = this.decorateElement(element, placements);
+ newElements.push(elementFinishersExtras.element);
+ newElements.push.apply(newElements, elementFinishersExtras.extras);
+ finishers.push.apply(finishers, elementFinishersExtras.finishers);
+ }, this);
+
+ if (!decorators) {
+ return {
+ elements: newElements,
+ finishers: finishers
+ };
+ }
+
+ var result = this.decorateConstructor(newElements, decorators);
+ finishers.push.apply(finishers, result.finishers);
+ result.finishers = finishers;
+ return result;
+ },
+ addElementPlacement: function addElementPlacement(element, placements, silent) {
+ var keys = placements[element.placement];
+
+ if (!silent && keys.indexOf(element.key) !== -1) {
+ throw new TypeError("Duplicated element (" + element.key + ")");
+ }
+
+ keys.push(element.key);
+ },
+ decorateElement: function decorateElement(element, placements) {
+ var extras = [];
+ var finishers = [];
+
+ for (var decorators = element.decorators, i = decorators.length - 1; i >= 0; i--) {
+ var keys = placements[element.placement];
+ keys.splice(keys.indexOf(element.key), 1);
+ var elementObject = this.fromElementDescriptor(element);
+ var elementFinisherExtras = this.toElementFinisherExtras((0, decorators[i])(elementObject) || elementObject);
+ element = elementFinisherExtras.element;
+ this.addElementPlacement(element, placements);
+
+ if (elementFinisherExtras.finisher) {
+ finishers.push(elementFinisherExtras.finisher);
+ }
+
+ var newExtras = elementFinisherExtras.extras;
+
+ if (newExtras) {
+ for (var j = 0; j < newExtras.length; j++) {
+ this.addElementPlacement(newExtras[j], placements);
+ }
+
+ extras.push.apply(extras, newExtras);
+ }
+ }
+
+ return {
+ element: element,
+ finishers: finishers,
+ extras: extras
+ };
+ },
+ decorateConstructor: function decorateConstructor(elements, decorators) {
+ var finishers = [];
+
+ for (var i = decorators.length - 1; i >= 0; i--) {
+ var obj = this.fromClassDescriptor(elements);
+ var elementsAndFinisher = this.toClassDescriptor((0, decorators[i])(obj) || obj);
+
+ if (elementsAndFinisher.finisher !== undefined) {
+ finishers.push(elementsAndFinisher.finisher);
+ }
+
+ if (elementsAndFinisher.elements !== undefined) {
+ elements = elementsAndFinisher.elements;
+
+ for (var j = 0; j < elements.length - 1; j++) {
+ for (var k = j + 1; k < elements.length; k++) {
+ if (elements[j].key === elements[k].key && elements[j].placement === elements[k].placement) {
+ throw new TypeError("Duplicated element (" + elements[j].key + ")");
+ }
+ }
+ }
+ }
+ }
+
+ return {
+ elements: elements,
+ finishers: finishers
+ };
+ },
+ fromElementDescriptor: function fromElementDescriptor(element) {
+ var obj = {
+ kind: element.kind,
+ key: element.key,
+ placement: element.placement,
+ descriptor: element.descriptor
+ };
+ var desc = {
+ value: "Descriptor",
+ configurable: true
+ };
+ Object.defineProperty(obj, Symbol.toStringTag, desc);
+ if (element.kind === "field") obj.initializer = element.initializer;
+ return obj;
+ },
+ toElementDescriptors: function toElementDescriptors(elementObjects) {
+ if (elementObjects === undefined) return;
+ return toArray(elementObjects).map(function (elementObject) {
+ var element = this.toElementDescriptor(elementObject);
+ this.disallowProperty(elementObject, "finisher", "An element descriptor");
+ this.disallowProperty(elementObject, "extras", "An element descriptor");
+ return element;
+ }, this);
+ },
+ toElementDescriptor: function toElementDescriptor(elementObject) {
+ var kind = String(elementObject.kind);
+
+ if (kind !== "method" && kind !== "field") {
+ throw new TypeError('An element descriptor\'s .kind property must be either "method" or' + ' "field", but a decorator created an element descriptor with' + ' .kind "' + kind + '"');
+ }
+
+ var key = toPropertyKey(elementObject.key);
+ var placement = String(elementObject.placement);
+
+ if (placement !== "static" && placement !== "prototype" && placement !== "own") {
+ throw new TypeError('An element descriptor\'s .placement property must be one of "static",' + ' "prototype" or "own", but a decorator created an element descriptor' + ' with .placement "' + placement + '"');
+ }
+
+ var descriptor = elementObject.descriptor;
+ this.disallowProperty(elementObject, "elements", "An element descriptor");
+ var element = {
+ kind: kind,
+ key: key,
+ placement: placement,
+ descriptor: Object.assign({}, descriptor)
+ };
+
+ if (kind !== "field") {
+ this.disallowProperty(elementObject, "initializer", "A method descriptor");
+ } else {
+ this.disallowProperty(descriptor, "get", "The property descriptor of a field descriptor");
+ this.disallowProperty(descriptor, "set", "The property descriptor of a field descriptor");
+ this.disallowProperty(descriptor, "value", "The property descriptor of a field descriptor");
+ element.initializer = elementObject.initializer;
+ }
+
+ return element;
+ },
+ toElementFinisherExtras: function toElementFinisherExtras(elementObject) {
+ var element = this.toElementDescriptor(elementObject);
+
+ var finisher = _optionalCallableProperty(elementObject, "finisher");
+
+ var extras = this.toElementDescriptors(elementObject.extras);
+ return {
+ element: element,
+ finisher: finisher,
+ extras: extras
+ };
+ },
+ fromClassDescriptor: function fromClassDescriptor(elements) {
+ var obj = {
+ kind: "class",
+ elements: elements.map(this.fromElementDescriptor, this)
+ };
+ var desc = {
+ value: "Descriptor",
+ configurable: true
+ };
+ Object.defineProperty(obj, Symbol.toStringTag, desc);
+ return obj;
+ },
+ toClassDescriptor: function toClassDescriptor(obj) {
+ var kind = String(obj.kind);
+
+ if (kind !== "class") {
+ throw new TypeError('A class descriptor\'s .kind property must be "class", but a decorator' + ' created a class descriptor with .kind "' + kind + '"');
+ }
+
+ this.disallowProperty(obj, "key", "A class descriptor");
+ this.disallowProperty(obj, "placement", "A class descriptor");
+ this.disallowProperty(obj, "descriptor", "A class descriptor");
+ this.disallowProperty(obj, "initializer", "A class descriptor");
+ this.disallowProperty(obj, "extras", "A class descriptor");
+
+ var finisher = _optionalCallableProperty(obj, "finisher");
+
+ var elements = this.toElementDescriptors(obj.elements);
+ return {
+ elements: elements,
+ finisher: finisher
+ };
+ },
+ runClassFinishers: function runClassFinishers(constructor, finishers) {
+ for (var i = 0; i < finishers.length; i++) {
+ var newConstructor = (0, finishers[i])(constructor);
+
+ if (newConstructor !== undefined) {
+ if (typeof newConstructor !== "function") {
+ throw new TypeError("Finishers must return a constructor.");
+ }
+
+ constructor = newConstructor;
+ }
+ }
+
+ return constructor;
+ },
+ disallowProperty: function disallowProperty(obj, name, objectType) {
+ if (obj[name] !== undefined) {
+ throw new TypeError(objectType + " can't have a ." + name + " property.");
+ }
+ }
+ };
+ return api;
+}
+
+function _createElementDescriptor(def) {
+ var key = toPropertyKey(def.key);
+ var descriptor;
+
+ if (def.kind === "method") {
+ descriptor = {
+ value: def.value,
+ writable: true,
+ configurable: true,
+ enumerable: false
+ };
+ } else if (def.kind === "get") {
+ descriptor = {
+ get: def.value,
+ configurable: true,
+ enumerable: false
+ };
+ } else if (def.kind === "set") {
+ descriptor = {
+ set: def.value,
+ configurable: true,
+ enumerable: false
+ };
+ } else if (def.kind === "field") {
+ descriptor = {
+ configurable: true,
+ writable: true,
+ enumerable: true
+ };
+ }
+
+ var element = {
+ kind: def.kind === "field" ? "field" : "method",
+ key: key,
+ placement: def["static"] ? "static" : def.kind === "field" ? "own" : "prototype",
+ descriptor: descriptor
+ };
+ if (def.decorators) element.decorators = def.decorators;
+ if (def.kind === "field") element.initializer = def.value;
+ return element;
+}
+
+function _coalesceGetterSetter(element, other) {
+ if (element.descriptor.get !== undefined) {
+ other.descriptor.get = element.descriptor.get;
+ } else {
+ other.descriptor.set = element.descriptor.set;
+ }
+}
+
+function _coalesceClassElements(elements) {
+ var newElements = [];
+
+ var isSameElement = function isSameElement(other) {
+ return other.kind === "method" && other.key === element.key && other.placement === element.placement;
+ };
+
+ for (var i = 0; i < elements.length; i++) {
+ var element = elements[i];
+ var other;
+
+ if (element.kind === "method" && (other = newElements.find(isSameElement))) {
+ if (_isDataDescriptor(element.descriptor) || _isDataDescriptor(other.descriptor)) {
+ if (_hasDecorators(element) || _hasDecorators(other)) {
+ throw new ReferenceError("Duplicated methods (" + element.key + ") can't be decorated.");
+ }
+
+ other.descriptor = element.descriptor;
+ } else {
+ if (_hasDecorators(element)) {
+ if (_hasDecorators(other)) {
+ throw new ReferenceError("Decorators can't be placed on different accessors with for " + "the same property (" + element.key + ").");
+ }
+
+ other.decorators = element.decorators;
+ }
+
+ _coalesceGetterSetter(element, other);
+ }
+ } else {
+ newElements.push(element);
+ }
+ }
+
+ return newElements;
+}
+
+function _hasDecorators(element) {
+ return element.decorators && element.decorators.length;
+}
+
+function _isDataDescriptor(desc) {
+ return desc !== undefined && !(desc.value === undefined && desc.writable === undefined);
+}
+
+function _optionalCallableProperty(obj, name) {
+ var value = obj[name];
+
+ if (value !== undefined && typeof value !== "function") {
+ throw new TypeError("Expected '" + name + "' to be a function");
+ }
+
+ return value;
+}
+
+module.exports = _decorate, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/defaults.js b/node_modules/@babel/runtime/helpers/defaults.js
new file mode 100644
index 000000000..6c1c196d5
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/defaults.js
@@ -0,0 +1,16 @@
+function _defaults(obj, defaults) {
+ var keys = Object.getOwnPropertyNames(defaults);
+
+ for (var i = 0; i < keys.length; i++) {
+ var key = keys[i];
+ var value = Object.getOwnPropertyDescriptor(defaults, key);
+
+ if (value && value.configurable && obj[key] === undefined) {
+ Object.defineProperty(obj, key, value);
+ }
+ }
+
+ return obj;
+}
+
+module.exports = _defaults, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/defineEnumerableProperties.js b/node_modules/@babel/runtime/helpers/defineEnumerableProperties.js
new file mode 100644
index 000000000..cd491282d
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/defineEnumerableProperties.js
@@ -0,0 +1,24 @@
+function _defineEnumerableProperties(obj, descs) {
+ for (var key in descs) {
+ var desc = descs[key];
+ desc.configurable = desc.enumerable = true;
+ if ("value" in desc) desc.writable = true;
+ Object.defineProperty(obj, key, desc);
+ }
+
+ if (Object.getOwnPropertySymbols) {
+ var objectSymbols = Object.getOwnPropertySymbols(descs);
+
+ for (var i = 0; i < objectSymbols.length; i++) {
+ var sym = objectSymbols[i];
+ var desc = descs[sym];
+ desc.configurable = desc.enumerable = true;
+ if ("value" in desc) desc.writable = true;
+ Object.defineProperty(obj, sym, desc);
+ }
+ }
+
+ return obj;
+}
+
+module.exports = _defineEnumerableProperties, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/defineProperty.js b/node_modules/@babel/runtime/helpers/defineProperty.js
new file mode 100644
index 000000000..fe7d6bb9c
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/defineProperty.js
@@ -0,0 +1,16 @@
+function _defineProperty(obj, key, value) {
+ if (key in obj) {
+ Object.defineProperty(obj, key, {
+ value: value,
+ enumerable: true,
+ configurable: true,
+ writable: true
+ });
+ } else {
+ obj[key] = value;
+ }
+
+ return obj;
+}
+
+module.exports = _defineProperty, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/AsyncGenerator.js b/node_modules/@babel/runtime/helpers/esm/AsyncGenerator.js
new file mode 100644
index 000000000..919aab875
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/AsyncGenerator.js
@@ -0,0 +1,95 @@
+import AwaitValue from "./AwaitValue.js";
+export default function AsyncGenerator(gen) {
+ var front, back;
+
+ function send(key, arg) {
+ return new Promise(function (resolve, reject) {
+ var request = {
+ key: key,
+ arg: arg,
+ resolve: resolve,
+ reject: reject,
+ next: null
+ };
+
+ if (back) {
+ back = back.next = request;
+ } else {
+ front = back = request;
+ resume(key, arg);
+ }
+ });
+ }
+
+ function resume(key, arg) {
+ try {
+ var result = gen[key](arg);
+ var value = result.value;
+ var wrappedAwait = value instanceof AwaitValue;
+ Promise.resolve(wrappedAwait ? value.wrapped : value).then(function (arg) {
+ if (wrappedAwait) {
+ resume(key === "return" ? "return" : "next", arg);
+ return;
+ }
+
+ settle(result.done ? "return" : "normal", arg);
+ }, function (err) {
+ resume("throw", err);
+ });
+ } catch (err) {
+ settle("throw", err);
+ }
+ }
+
+ function settle(type, value) {
+ switch (type) {
+ case "return":
+ front.resolve({
+ value: value,
+ done: true
+ });
+ break;
+
+ case "throw":
+ front.reject(value);
+ break;
+
+ default:
+ front.resolve({
+ value: value,
+ done: false
+ });
+ break;
+ }
+
+ front = front.next;
+
+ if (front) {
+ resume(front.key, front.arg);
+ } else {
+ back = null;
+ }
+ }
+
+ this._invoke = send;
+
+ if (typeof gen["return"] !== "function") {
+ this["return"] = undefined;
+ }
+}
+
+AsyncGenerator.prototype[typeof Symbol === "function" && Symbol.asyncIterator || "@@asyncIterator"] = function () {
+ return this;
+};
+
+AsyncGenerator.prototype.next = function (arg) {
+ return this._invoke("next", arg);
+};
+
+AsyncGenerator.prototype["throw"] = function (arg) {
+ return this._invoke("throw", arg);
+};
+
+AsyncGenerator.prototype["return"] = function (arg) {
+ return this._invoke("return", arg);
+};
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/AwaitValue.js b/node_modules/@babel/runtime/helpers/esm/AwaitValue.js
new file mode 100644
index 000000000..5237e18fd
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/AwaitValue.js
@@ -0,0 +1,3 @@
+export default function _AwaitValue(value) {
+ this.wrapped = value;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/applyDecoratedDescriptor.js b/node_modules/@babel/runtime/helpers/esm/applyDecoratedDescriptor.js
new file mode 100644
index 000000000..84b59617c
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/applyDecoratedDescriptor.js
@@ -0,0 +1,28 @@
+export default function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) {
+ var desc = {};
+ Object.keys(descriptor).forEach(function (key) {
+ desc[key] = descriptor[key];
+ });
+ desc.enumerable = !!desc.enumerable;
+ desc.configurable = !!desc.configurable;
+
+ if ('value' in desc || desc.initializer) {
+ desc.writable = true;
+ }
+
+ desc = decorators.slice().reverse().reduce(function (desc, decorator) {
+ return decorator(target, property, desc) || desc;
+ }, desc);
+
+ if (context && desc.initializer !== void 0) {
+ desc.value = desc.initializer ? desc.initializer.call(context) : void 0;
+ desc.initializer = undefined;
+ }
+
+ if (desc.initializer === void 0) {
+ Object.defineProperty(target, property, desc);
+ desc = null;
+ }
+
+ return desc;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/applyDecs.js b/node_modules/@babel/runtime/helpers/esm/applyDecs.js
new file mode 100644
index 000000000..d6ee9f133
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/applyDecs.js
@@ -0,0 +1,254 @@
+import _typeof from "./typeof.js";
+
+function createMetadataMethodsForProperty(metadataMap, kind, property) {
+ return {
+ getMetadata: function getMetadata(key) {
+ if ("symbol" != _typeof(key)) throw new TypeError("Metadata keys must be symbols, received: " + key);
+ var metadataForKey = metadataMap[key];
+ if (void 0 !== metadataForKey) if (1 === kind) {
+ var pub = metadataForKey["public"];
+ if (void 0 !== pub) return pub[property];
+ } else if (2 === kind) {
+ var priv = metadataForKey["private"];
+ if (void 0 !== priv) return priv.get(property);
+ } else if (Object.hasOwnProperty.call(metadataForKey, "constructor")) return metadataForKey.constructor;
+ },
+ setMetadata: function setMetadata(key, value) {
+ if ("symbol" != _typeof(key)) throw new TypeError("Metadata keys must be symbols, received: " + key);
+ var metadataForKey = metadataMap[key];
+
+ if (void 0 === metadataForKey && (metadataForKey = metadataMap[key] = {}), 1 === kind) {
+ var pub = metadataForKey["public"];
+ void 0 === pub && (pub = metadataForKey["public"] = {}), pub[property] = value;
+ } else if (2 === kind) {
+ var priv = metadataForKey.priv;
+ void 0 === priv && (priv = metadataForKey["private"] = new Map()), priv.set(property, value);
+ } else metadataForKey.constructor = value;
+ }
+ };
+}
+
+function convertMetadataMapToFinal(obj, metadataMap) {
+ var parentMetadataMap = obj[Symbol.metadata || Symbol["for"]("Symbol.metadata")],
+ metadataKeys = Object.getOwnPropertySymbols(metadataMap);
+
+ if (0 !== metadataKeys.length) {
+ for (var i = 0; i < metadataKeys.length; i++) {
+ var key = metadataKeys[i],
+ metaForKey = metadataMap[key],
+ parentMetaForKey = parentMetadataMap ? parentMetadataMap[key] : null,
+ pub = metaForKey["public"],
+ parentPub = parentMetaForKey ? parentMetaForKey["public"] : null;
+ pub && parentPub && Object.setPrototypeOf(pub, parentPub);
+ var priv = metaForKey["private"];
+
+ if (priv) {
+ var privArr = Array.from(priv.values()),
+ parentPriv = parentMetaForKey ? parentMetaForKey["private"] : null;
+ parentPriv && (privArr = privArr.concat(parentPriv)), metaForKey["private"] = privArr;
+ }
+
+ parentMetaForKey && Object.setPrototypeOf(metaForKey, parentMetaForKey);
+ }
+
+ parentMetadataMap && Object.setPrototypeOf(metadataMap, parentMetadataMap), obj[Symbol.metadata || Symbol["for"]("Symbol.metadata")] = metadataMap;
+ }
+}
+
+function createAddInitializerMethod(initializers) {
+ return function (initializer) {
+ assertValidInitializer(initializer), initializers.push(initializer);
+ };
+}
+
+function memberDecCtx(base, name, desc, metadataMap, initializers, kind, isStatic, isPrivate) {
+ var kindStr;
+
+ switch (kind) {
+ case 1:
+ kindStr = "accessor";
+ break;
+
+ case 2:
+ kindStr = "method";
+ break;
+
+ case 3:
+ kindStr = "getter";
+ break;
+
+ case 4:
+ kindStr = "setter";
+ break;
+
+ default:
+ kindStr = "field";
+ }
+
+ var metadataKind,
+ metadataName,
+ ctx = {
+ kind: kindStr,
+ name: isPrivate ? "#" + name : name,
+ isStatic: isStatic,
+ isPrivate: isPrivate
+ };
+
+ if (0 !== kind && (ctx.addInitializer = createAddInitializerMethod(initializers)), isPrivate) {
+ metadataKind = 2, metadataName = Symbol(name);
+ var access = {};
+ 0 === kind ? (access.get = desc.get, access.set = desc.set) : 2 === kind ? access.get = function () {
+ return desc.value;
+ } : (1 !== kind && 3 !== kind || (access.get = function () {
+ return desc.get.call(this);
+ }), 1 !== kind && 4 !== kind || (access.set = function (v) {
+ desc.set.call(this, v);
+ })), ctx.access = access;
+ } else metadataKind = 1, metadataName = name;
+
+ return Object.assign(ctx, createMetadataMethodsForProperty(metadataMap, metadataKind, metadataName));
+}
+
+function assertValidInitializer(initializer) {
+ if ("function" != typeof initializer) throw new Error("initializers must be functions");
+}
+
+function assertValidReturnValue(kind, value) {
+ var type = _typeof(value);
+
+ if (1 === kind) {
+ if ("object" !== type || null === value) throw new Error("accessor decorators must return an object with get, set, or initializer properties or void 0");
+ } else if ("function" !== type) throw 0 === kind ? new Error("field decorators must return a initializer function or void 0") : new Error("method decorators must return a function or void 0");
+}
+
+function applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, metadataMap, initializers) {
+ var desc,
+ initializer,
+ value,
+ decs = decInfo[0];
+ isPrivate ? desc = 0 === kind || 1 === kind ? {
+ get: decInfo[3],
+ set: decInfo[4]
+ } : 3 === kind ? {
+ get: decInfo[3]
+ } : 4 === kind ? {
+ set: decInfo[3]
+ } : {
+ value: decInfo[3]
+ } : 0 !== kind && (desc = Object.getOwnPropertyDescriptor(base, name)), 1 === kind ? value = {
+ get: desc.get,
+ set: desc.set
+ } : 2 === kind ? value = desc.value : 3 === kind ? value = desc.get : 4 === kind && (value = desc.set);
+ var newValue,
+ get,
+ set,
+ ctx = memberDecCtx(base, name, desc, metadataMap, initializers, kind, isStatic, isPrivate);
+ if ("function" == typeof decs) void 0 !== (newValue = decs(value, ctx)) && (assertValidReturnValue(kind, newValue), 0 === kind ? initializer = newValue : 1 === kind ? (initializer = newValue.initializer, get = newValue.get || value.get, set = newValue.set || value.set, value = {
+ get: get,
+ set: set
+ }) : value = newValue);else for (var i = decs.length - 1; i >= 0; i--) {
+ var newInit;
+ if (void 0 !== (newValue = (0, decs[i])(value, ctx))) assertValidReturnValue(kind, newValue), 0 === kind ? newInit = newValue : 1 === kind ? (newInit = newValue.initializer, get = newValue.get || value.get, set = newValue.set || value.set, value = {
+ get: get,
+ set: set
+ }) : value = newValue, void 0 !== newInit && (void 0 === initializer ? initializer = newInit : "function" == typeof initializer ? initializer = [initializer, newInit] : initializer.push(newInit));
+ }
+
+ if (0 === kind || 1 === kind) {
+ if (void 0 === initializer) initializer = function initializer(instance, init) {
+ return init;
+ };else if ("function" != typeof initializer) {
+ var ownInitializers = initializer;
+
+ initializer = function initializer(instance, init) {
+ for (var value = init, i = 0; i < ownInitializers.length; i++) {
+ value = ownInitializers[i].call(instance, value);
+ }
+
+ return value;
+ };
+ } else {
+ var originalInitializer = initializer;
+
+ initializer = function initializer(instance, init) {
+ return originalInitializer.call(instance, init);
+ };
+ }
+ ret.push(initializer);
+ }
+
+ 0 !== kind && (1 === kind ? (desc.get = value.get, desc.set = value.set) : 2 === kind ? desc.value = value : 3 === kind ? desc.get = value : 4 === kind && (desc.set = value), isPrivate ? 1 === kind ? (ret.push(function (instance, args) {
+ return value.get.call(instance, args);
+ }), ret.push(function (instance, args) {
+ return value.set.call(instance, args);
+ })) : 2 === kind ? ret.push(value) : ret.push(function (instance, args) {
+ return value.call(instance, args);
+ }) : Object.defineProperty(base, name, desc));
+}
+
+function applyMemberDecs(ret, Class, protoMetadataMap, staticMetadataMap, decInfos) {
+ for (var protoInitializers = [], staticInitializers = [], existingProtoNonFields = new Map(), existingStaticNonFields = new Map(), i = 0; i < decInfos.length; i++) {
+ var decInfo = decInfos[i];
+
+ if (Array.isArray(decInfo)) {
+ var base,
+ metadataMap,
+ initializers,
+ kind = decInfo[1],
+ name = decInfo[2],
+ isPrivate = decInfo.length > 3,
+ isStatic = kind >= 5;
+
+ if (isStatic ? (base = Class, metadataMap = staticMetadataMap, kind -= 5, initializers = staticInitializers) : (base = Class.prototype, metadataMap = protoMetadataMap, initializers = protoInitializers), 0 !== kind && !isPrivate) {
+ var existingNonFields = isStatic ? existingStaticNonFields : existingProtoNonFields,
+ existingKind = existingNonFields.get(name) || 0;
+ if (!0 === existingKind || 3 === existingKind && 4 !== kind || 4 === existingKind && 3 !== kind) throw new Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + name);
+ !existingKind && kind > 2 ? existingNonFields.set(name, kind) : existingNonFields.set(name, !0);
+ }
+
+ applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, metadataMap, initializers);
+ }
+ }
+
+ protoInitializers.length > 0 && pushInitializers(ret, protoInitializers), staticInitializers.length > 0 && pushInitializers(ret, staticInitializers);
+}
+
+function pushInitializers(ret, initializers) {
+ initializers.length > 0 ? (initializers = initializers.slice(), ret.push(function (instance) {
+ for (var i = 0; i < initializers.length; i++) {
+ initializers[i].call(instance, instance);
+ }
+
+ return instance;
+ })) : ret.push(function (instance) {
+ return instance;
+ });
+}
+
+function applyClassDecs(ret, targetClass, metadataMap, classDecs) {
+ for (var initializers = [], newClass = targetClass, name = targetClass.name, ctx = Object.assign({
+ kind: "class",
+ name: name,
+ addInitializer: createAddInitializerMethod(initializers)
+ }, createMetadataMethodsForProperty(metadataMap, 0, name)), i = classDecs.length - 1; i >= 0; i--) {
+ newClass = classDecs[i](newClass, ctx) || newClass;
+ }
+
+ ret.push(newClass), initializers.length > 0 ? ret.push(function () {
+ for (var i = 0; i < initializers.length; i++) {
+ initializers[i].call(newClass, newClass);
+ }
+ }) : ret.push(function () {});
+}
+
+export default function applyDecs(targetClass, memberDecs, classDecs) {
+ var ret = [],
+ staticMetadataMap = {};
+
+ if (memberDecs) {
+ var protoMetadataMap = {};
+ applyMemberDecs(ret, targetClass, protoMetadataMap, staticMetadataMap, memberDecs), convertMetadataMapToFinal(targetClass.prototype, protoMetadataMap);
+ }
+
+ return classDecs && applyClassDecs(ret, targetClass, staticMetadataMap, classDecs), convertMetadataMapToFinal(targetClass, staticMetadataMap), ret;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js b/node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js
new file mode 100644
index 000000000..edbeb8ee3
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js
@@ -0,0 +1,9 @@
+export default function _arrayLikeToArray(arr, len) {
+ if (len == null || len > arr.length) len = arr.length;
+
+ for (var i = 0, arr2 = new Array(len); i < len; i++) {
+ arr2[i] = arr[i];
+ }
+
+ return arr2;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js b/node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js
new file mode 100644
index 000000000..be734fc38
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js
@@ -0,0 +1,3 @@
+export default function _arrayWithHoles(arr) {
+ if (Array.isArray(arr)) return arr;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/arrayWithoutHoles.js b/node_modules/@babel/runtime/helpers/esm/arrayWithoutHoles.js
new file mode 100644
index 000000000..f7d8dc781
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/arrayWithoutHoles.js
@@ -0,0 +1,4 @@
+import arrayLikeToArray from "./arrayLikeToArray.js";
+export default function _arrayWithoutHoles(arr) {
+ if (Array.isArray(arr)) return arrayLikeToArray(arr);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/assertThisInitialized.js b/node_modules/@babel/runtime/helpers/esm/assertThisInitialized.js
new file mode 100644
index 000000000..bbf849ca5
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/assertThisInitialized.js
@@ -0,0 +1,7 @@
+export default function _assertThisInitialized(self) {
+ if (self === void 0) {
+ throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+ }
+
+ return self;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/asyncGeneratorDelegate.js b/node_modules/@babel/runtime/helpers/esm/asyncGeneratorDelegate.js
new file mode 100644
index 000000000..a7ccd6754
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/asyncGeneratorDelegate.js
@@ -0,0 +1,54 @@
+export default function _asyncGeneratorDelegate(inner, awaitWrap) {
+ var iter = {},
+ waiting = false;
+
+ function pump(key, value) {
+ waiting = true;
+ value = new Promise(function (resolve) {
+ resolve(inner[key](value));
+ });
+ return {
+ done: false,
+ value: awaitWrap(value)
+ };
+ }
+
+ ;
+
+ iter[typeof Symbol !== "undefined" && Symbol.iterator || "@@iterator"] = function () {
+ return this;
+ };
+
+ iter.next = function (value) {
+ if (waiting) {
+ waiting = false;
+ return value;
+ }
+
+ return pump("next", value);
+ };
+
+ if (typeof inner["throw"] === "function") {
+ iter["throw"] = function (value) {
+ if (waiting) {
+ waiting = false;
+ throw value;
+ }
+
+ return pump("throw", value);
+ };
+ }
+
+ if (typeof inner["return"] === "function") {
+ iter["return"] = function (value) {
+ if (waiting) {
+ waiting = false;
+ return value;
+ }
+
+ return pump("return", value);
+ };
+ }
+
+ return iter;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/asyncIterator.js b/node_modules/@babel/runtime/helpers/esm/asyncIterator.js
new file mode 100644
index 000000000..030c44e09
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/asyncIterator.js
@@ -0,0 +1,48 @@
+export default function _asyncIterator(iterable) {
+ var method,
+ async,
+ sync,
+ retry = 2;
+
+ for ("undefined" != typeof Symbol && (async = Symbol.asyncIterator, sync = Symbol.iterator); retry--;) {
+ if (async && null != (method = iterable[async])) return method.call(iterable);
+ if (sync && null != (method = iterable[sync])) return new AsyncFromSyncIterator(method.call(iterable));
+ async = "@@asyncIterator", sync = "@@iterator";
+ }
+
+ throw new TypeError("Object is not async iterable");
+}
+
+function AsyncFromSyncIterator(s) {
+ function AsyncFromSyncIteratorContinuation(r) {
+ if (Object(r) !== r) return Promise.reject(new TypeError(r + " is not an object."));
+ var done = r.done;
+ return Promise.resolve(r.value).then(function (value) {
+ return {
+ value: value,
+ done: done
+ };
+ });
+ }
+
+ return AsyncFromSyncIterator = function AsyncFromSyncIterator(s) {
+ this.s = s, this.n = s.next;
+ }, AsyncFromSyncIterator.prototype = {
+ s: null,
+ n: null,
+ next: function next() {
+ return AsyncFromSyncIteratorContinuation(this.n.apply(this.s, arguments));
+ },
+ "return": function _return(value) {
+ var ret = this.s["return"];
+ return void 0 === ret ? Promise.resolve({
+ value: value,
+ done: !0
+ }) : AsyncFromSyncIteratorContinuation(ret.apply(this.s, arguments));
+ },
+ "throw": function _throw(value) {
+ var thr = this.s["return"];
+ return void 0 === thr ? Promise.reject(value) : AsyncFromSyncIteratorContinuation(thr.apply(this.s, arguments));
+ }
+ }, new AsyncFromSyncIterator(s);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js b/node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js
new file mode 100644
index 000000000..2a25f543b
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js
@@ -0,0 +1,35 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+ try {
+ var info = gen[key](arg);
+ var value = info.value;
+ } catch (error) {
+ reject(error);
+ return;
+ }
+
+ if (info.done) {
+ resolve(value);
+ } else {
+ Promise.resolve(value).then(_next, _throw);
+ }
+}
+
+export default function _asyncToGenerator(fn) {
+ return function () {
+ var self = this,
+ args = arguments;
+ return new Promise(function (resolve, reject) {
+ var gen = fn.apply(self, args);
+
+ function _next(value) {
+ asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+ }
+
+ function _throw(err) {
+ asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+ }
+
+ _next(undefined);
+ });
+ };
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/awaitAsyncGenerator.js b/node_modules/@babel/runtime/helpers/esm/awaitAsyncGenerator.js
new file mode 100644
index 000000000..ccca65e53
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/awaitAsyncGenerator.js
@@ -0,0 +1,4 @@
+import AwaitValue from "./AwaitValue.js";
+export default function _awaitAsyncGenerator(value) {
+ return new AwaitValue(value);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/checkPrivateRedeclaration.js b/node_modules/@babel/runtime/helpers/esm/checkPrivateRedeclaration.js
new file mode 100644
index 000000000..990140366
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/checkPrivateRedeclaration.js
@@ -0,0 +1,5 @@
+export default function _checkPrivateRedeclaration(obj, privateCollection) {
+ if (privateCollection.has(obj)) {
+ throw new TypeError("Cannot initialize the same private elements twice on an object");
+ }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/classApplyDescriptorDestructureSet.js b/node_modules/@babel/runtime/helpers/esm/classApplyDescriptorDestructureSet.js
new file mode 100644
index 000000000..4472adc64
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/classApplyDescriptorDestructureSet.js
@@ -0,0 +1,20 @@
+export default function _classApplyDescriptorDestructureSet(receiver, descriptor) {
+ if (descriptor.set) {
+ if (!("__destrObj" in descriptor)) {
+ descriptor.__destrObj = {
+ set value(v) {
+ descriptor.set.call(receiver, v);
+ }
+
+ };
+ }
+
+ return descriptor.__destrObj;
+ } else {
+ if (!descriptor.writable) {
+ throw new TypeError("attempted to set read only private field");
+ }
+
+ return descriptor;
+ }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/classApplyDescriptorGet.js b/node_modules/@babel/runtime/helpers/esm/classApplyDescriptorGet.js
new file mode 100644
index 000000000..0fad169d5
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/classApplyDescriptorGet.js
@@ -0,0 +1,7 @@
+export default function _classApplyDescriptorGet(receiver, descriptor) {
+ if (descriptor.get) {
+ return descriptor.get.call(receiver);
+ }
+
+ return descriptor.value;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/classApplyDescriptorSet.js b/node_modules/@babel/runtime/helpers/esm/classApplyDescriptorSet.js
new file mode 100644
index 000000000..f295f3e36
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/classApplyDescriptorSet.js
@@ -0,0 +1,11 @@
+export default function _classApplyDescriptorSet(receiver, descriptor, value) {
+ if (descriptor.set) {
+ descriptor.set.call(receiver, value);
+ } else {
+ if (!descriptor.writable) {
+ throw new TypeError("attempted to set read only private field");
+ }
+
+ descriptor.value = value;
+ }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/classCallCheck.js b/node_modules/@babel/runtime/helpers/esm/classCallCheck.js
new file mode 100644
index 000000000..2f1738a3d
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/classCallCheck.js
@@ -0,0 +1,5 @@
+export default function _classCallCheck(instance, Constructor) {
+ if (!(instance instanceof Constructor)) {
+ throw new TypeError("Cannot call a class as a function");
+ }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/classCheckPrivateStaticAccess.js b/node_modules/@babel/runtime/helpers/esm/classCheckPrivateStaticAccess.js
new file mode 100644
index 000000000..098ed3090
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/classCheckPrivateStaticAccess.js
@@ -0,0 +1,5 @@
+export default function _classCheckPrivateStaticAccess(receiver, classConstructor) {
+ if (receiver !== classConstructor) {
+ throw new TypeError("Private static access of wrong provenance");
+ }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/classCheckPrivateStaticFieldDescriptor.js b/node_modules/@babel/runtime/helpers/esm/classCheckPrivateStaticFieldDescriptor.js
new file mode 100644
index 000000000..0ef34b8d7
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/classCheckPrivateStaticFieldDescriptor.js
@@ -0,0 +1,5 @@
+export default function _classCheckPrivateStaticFieldDescriptor(descriptor, action) {
+ if (descriptor === undefined) {
+ throw new TypeError("attempted to " + action + " private static field before its declaration");
+ }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/classExtractFieldDescriptor.js b/node_modules/@babel/runtime/helpers/esm/classExtractFieldDescriptor.js
new file mode 100644
index 000000000..8dabe9a32
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/classExtractFieldDescriptor.js
@@ -0,0 +1,7 @@
+export default function _classExtractFieldDescriptor(receiver, privateMap, action) {
+ if (!privateMap.has(receiver)) {
+ throw new TypeError("attempted to " + action + " private field on non-instance");
+ }
+
+ return privateMap.get(receiver);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/classNameTDZError.js b/node_modules/@babel/runtime/helpers/esm/classNameTDZError.js
new file mode 100644
index 000000000..f7b6dd578
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/classNameTDZError.js
@@ -0,0 +1,3 @@
+export default function _classNameTDZError(name) {
+ throw new Error("Class \"" + name + "\" cannot be referenced in computed property keys.");
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/classPrivateFieldDestructureSet.js b/node_modules/@babel/runtime/helpers/esm/classPrivateFieldDestructureSet.js
new file mode 100644
index 000000000..fb5883369
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/classPrivateFieldDestructureSet.js
@@ -0,0 +1,6 @@
+import classApplyDescriptorDestructureSet from "./classApplyDescriptorDestructureSet.js";
+import classExtractFieldDescriptor from "./classExtractFieldDescriptor.js";
+export default function _classPrivateFieldDestructureSet(receiver, privateMap) {
+ var descriptor = classExtractFieldDescriptor(receiver, privateMap, "set");
+ return classApplyDescriptorDestructureSet(receiver, descriptor);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/classPrivateFieldGet.js b/node_modules/@babel/runtime/helpers/esm/classPrivateFieldGet.js
new file mode 100644
index 000000000..53cd1379c
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/classPrivateFieldGet.js
@@ -0,0 +1,6 @@
+import classApplyDescriptorGet from "./classApplyDescriptorGet.js";
+import classExtractFieldDescriptor from "./classExtractFieldDescriptor.js";
+export default function _classPrivateFieldGet(receiver, privateMap) {
+ var descriptor = classExtractFieldDescriptor(receiver, privateMap, "get");
+ return classApplyDescriptorGet(receiver, descriptor);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/classPrivateFieldInitSpec.js b/node_modules/@babel/runtime/helpers/esm/classPrivateFieldInitSpec.js
new file mode 100644
index 000000000..2253dd84f
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/classPrivateFieldInitSpec.js
@@ -0,0 +1,5 @@
+import checkPrivateRedeclaration from "./checkPrivateRedeclaration.js";
+export default function _classPrivateFieldInitSpec(obj, privateMap, value) {
+ checkPrivateRedeclaration(obj, privateMap);
+ privateMap.set(obj, value);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/classPrivateFieldLooseBase.js b/node_modules/@babel/runtime/helpers/esm/classPrivateFieldLooseBase.js
new file mode 100644
index 000000000..5b10916f4
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/classPrivateFieldLooseBase.js
@@ -0,0 +1,7 @@
+export default function _classPrivateFieldBase(receiver, privateKey) {
+ if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) {
+ throw new TypeError("attempted to use private field on non-instance");
+ }
+
+ return receiver;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/classPrivateFieldLooseKey.js b/node_modules/@babel/runtime/helpers/esm/classPrivateFieldLooseKey.js
new file mode 100644
index 000000000..5b7e5ac02
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/classPrivateFieldLooseKey.js
@@ -0,0 +1,4 @@
+var id = 0;
+export default function _classPrivateFieldKey(name) {
+ return "__private_" + id++ + "_" + name;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/classPrivateFieldSet.js b/node_modules/@babel/runtime/helpers/esm/classPrivateFieldSet.js
new file mode 100644
index 000000000..ad91be440
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/classPrivateFieldSet.js
@@ -0,0 +1,7 @@
+import classApplyDescriptorSet from "./classApplyDescriptorSet.js";
+import classExtractFieldDescriptor from "./classExtractFieldDescriptor.js";
+export default function _classPrivateFieldSet(receiver, privateMap, value) {
+ var descriptor = classExtractFieldDescriptor(receiver, privateMap, "set");
+ classApplyDescriptorSet(receiver, descriptor, value);
+ return value;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/classPrivateMethodGet.js b/node_modules/@babel/runtime/helpers/esm/classPrivateMethodGet.js
new file mode 100644
index 000000000..38b9d584d
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/classPrivateMethodGet.js
@@ -0,0 +1,7 @@
+export default function _classPrivateMethodGet(receiver, privateSet, fn) {
+ if (!privateSet.has(receiver)) {
+ throw new TypeError("attempted to get private field on non-instance");
+ }
+
+ return fn;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/classPrivateMethodInitSpec.js b/node_modules/@babel/runtime/helpers/esm/classPrivateMethodInitSpec.js
new file mode 100644
index 000000000..18d129159
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/classPrivateMethodInitSpec.js
@@ -0,0 +1,5 @@
+import checkPrivateRedeclaration from "./checkPrivateRedeclaration.js";
+export default function _classPrivateMethodInitSpec(obj, privateSet) {
+ checkPrivateRedeclaration(obj, privateSet);
+ privateSet.add(obj);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/classPrivateMethodSet.js b/node_modules/@babel/runtime/helpers/esm/classPrivateMethodSet.js
new file mode 100644
index 000000000..2bbaf3a7a
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/classPrivateMethodSet.js
@@ -0,0 +1,3 @@
+export default function _classPrivateMethodSet() {
+ throw new TypeError("attempted to reassign private method");
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/classStaticPrivateFieldDestructureSet.js b/node_modules/@babel/runtime/helpers/esm/classStaticPrivateFieldDestructureSet.js
new file mode 100644
index 000000000..77afcfb18
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/classStaticPrivateFieldDestructureSet.js
@@ -0,0 +1,8 @@
+import classApplyDescriptorDestructureSet from "./classApplyDescriptorDestructureSet.js";
+import classCheckPrivateStaticAccess from "./classCheckPrivateStaticAccess.js";
+import classCheckPrivateStaticFieldDescriptor from "./classCheckPrivateStaticFieldDescriptor.js";
+export default function _classStaticPrivateFieldDestructureSet(receiver, classConstructor, descriptor) {
+ classCheckPrivateStaticAccess(receiver, classConstructor);
+ classCheckPrivateStaticFieldDescriptor(descriptor, "set");
+ return classApplyDescriptorDestructureSet(receiver, descriptor);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/classStaticPrivateFieldSpecGet.js b/node_modules/@babel/runtime/helpers/esm/classStaticPrivateFieldSpecGet.js
new file mode 100644
index 000000000..d253d3119
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/classStaticPrivateFieldSpecGet.js
@@ -0,0 +1,8 @@
+import classApplyDescriptorGet from "./classApplyDescriptorGet.js";
+import classCheckPrivateStaticAccess from "./classCheckPrivateStaticAccess.js";
+import classCheckPrivateStaticFieldDescriptor from "./classCheckPrivateStaticFieldDescriptor.js";
+export default function _classStaticPrivateFieldSpecGet(receiver, classConstructor, descriptor) {
+ classCheckPrivateStaticAccess(receiver, classConstructor);
+ classCheckPrivateStaticFieldDescriptor(descriptor, "get");
+ return classApplyDescriptorGet(receiver, descriptor);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/classStaticPrivateFieldSpecSet.js b/node_modules/@babel/runtime/helpers/esm/classStaticPrivateFieldSpecSet.js
new file mode 100644
index 000000000..b0b0cc644
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/classStaticPrivateFieldSpecSet.js
@@ -0,0 +1,9 @@
+import classApplyDescriptorSet from "./classApplyDescriptorSet.js";
+import classCheckPrivateStaticAccess from "./classCheckPrivateStaticAccess.js";
+import classCheckPrivateStaticFieldDescriptor from "./classCheckPrivateStaticFieldDescriptor.js";
+export default function _classStaticPrivateFieldSpecSet(receiver, classConstructor, descriptor, value) {
+ classCheckPrivateStaticAccess(receiver, classConstructor);
+ classCheckPrivateStaticFieldDescriptor(descriptor, "set");
+ classApplyDescriptorSet(receiver, descriptor, value);
+ return value;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/classStaticPrivateMethodGet.js b/node_modules/@babel/runtime/helpers/esm/classStaticPrivateMethodGet.js
new file mode 100644
index 000000000..fddc7b2d8
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/classStaticPrivateMethodGet.js
@@ -0,0 +1,5 @@
+import classCheckPrivateStaticAccess from "./classCheckPrivateStaticAccess.js";
+export default function _classStaticPrivateMethodGet(receiver, classConstructor, method) {
+ classCheckPrivateStaticAccess(receiver, classConstructor);
+ return method;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/classStaticPrivateMethodSet.js b/node_modules/@babel/runtime/helpers/esm/classStaticPrivateMethodSet.js
new file mode 100644
index 000000000..d5ab60a97
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/classStaticPrivateMethodSet.js
@@ -0,0 +1,3 @@
+export default function _classStaticPrivateMethodSet() {
+ throw new TypeError("attempted to set read only static private field");
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/construct.js b/node_modules/@babel/runtime/helpers/esm/construct.js
new file mode 100644
index 000000000..0c39835d2
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/construct.js
@@ -0,0 +1,18 @@
+import setPrototypeOf from "./setPrototypeOf.js";
+import isNativeReflectConstruct from "./isNativeReflectConstruct.js";
+export default function _construct(Parent, args, Class) {
+ if (isNativeReflectConstruct()) {
+ _construct = Reflect.construct;
+ } else {
+ _construct = function _construct(Parent, args, Class) {
+ var a = [null];
+ a.push.apply(a, args);
+ var Constructor = Function.bind.apply(Parent, a);
+ var instance = new Constructor();
+ if (Class) setPrototypeOf(instance, Class.prototype);
+ return instance;
+ };
+ }
+
+ return _construct.apply(null, arguments);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/createClass.js b/node_modules/@babel/runtime/helpers/esm/createClass.js
new file mode 100644
index 000000000..b32073158
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/createClass.js
@@ -0,0 +1,18 @@
+function _defineProperties(target, props) {
+ for (var i = 0; i < props.length; i++) {
+ var descriptor = props[i];
+ descriptor.enumerable = descriptor.enumerable || false;
+ descriptor.configurable = true;
+ if ("value" in descriptor) descriptor.writable = true;
+ Object.defineProperty(target, descriptor.key, descriptor);
+ }
+}
+
+export default function _createClass(Constructor, protoProps, staticProps) {
+ if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+ if (staticProps) _defineProperties(Constructor, staticProps);
+ Object.defineProperty(Constructor, "prototype", {
+ writable: false
+ });
+ return Constructor;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/createForOfIteratorHelper.js b/node_modules/@babel/runtime/helpers/esm/createForOfIteratorHelper.js
new file mode 100644
index 000000000..a7a2a50ad
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/createForOfIteratorHelper.js
@@ -0,0 +1,57 @@
+import unsupportedIterableToArray from "./unsupportedIterableToArray.js";
+export default function _createForOfIteratorHelper(o, allowArrayLike) {
+ var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+
+ if (!it) {
+ if (Array.isArray(o) || (it = unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+ if (it) o = it;
+ var i = 0;
+
+ var F = function F() {};
+
+ return {
+ s: F,
+ n: function n() {
+ if (i >= o.length) return {
+ done: true
+ };
+ return {
+ done: false,
+ value: o[i++]
+ };
+ },
+ e: function e(_e) {
+ throw _e;
+ },
+ f: F
+ };
+ }
+
+ throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+ }
+
+ var normalCompletion = true,
+ didErr = false,
+ err;
+ return {
+ s: function s() {
+ it = it.call(o);
+ },
+ n: function n() {
+ var step = it.next();
+ normalCompletion = step.done;
+ return step;
+ },
+ e: function e(_e2) {
+ didErr = true;
+ err = _e2;
+ },
+ f: function f() {
+ try {
+ if (!normalCompletion && it["return"] != null) it["return"]();
+ } finally {
+ if (didErr) throw err;
+ }
+ }
+ };
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/createForOfIteratorHelperLoose.js b/node_modules/@babel/runtime/helpers/esm/createForOfIteratorHelperLoose.js
new file mode 100644
index 000000000..640ec6831
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/createForOfIteratorHelperLoose.js
@@ -0,0 +1,21 @@
+import unsupportedIterableToArray from "./unsupportedIterableToArray.js";
+export default function _createForOfIteratorHelperLoose(o, allowArrayLike) {
+ var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+ if (it) return (it = it.call(o)).next.bind(it);
+
+ if (Array.isArray(o) || (it = unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+ if (it) o = it;
+ var i = 0;
+ return function () {
+ if (i >= o.length) return {
+ done: true
+ };
+ return {
+ done: false,
+ value: o[i++]
+ };
+ };
+ }
+
+ throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/createSuper.js b/node_modules/@babel/runtime/helpers/esm/createSuper.js
new file mode 100644
index 000000000..ea5ea9955
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/createSuper.js
@@ -0,0 +1,19 @@
+import getPrototypeOf from "./getPrototypeOf.js";
+import isNativeReflectConstruct from "./isNativeReflectConstruct.js";
+import possibleConstructorReturn from "./possibleConstructorReturn.js";
+export default function _createSuper(Derived) {
+ var hasNativeReflectConstruct = isNativeReflectConstruct();
+ return function _createSuperInternal() {
+ var Super = getPrototypeOf(Derived),
+ result;
+
+ if (hasNativeReflectConstruct) {
+ var NewTarget = getPrototypeOf(this).constructor;
+ result = Reflect.construct(Super, arguments, NewTarget);
+ } else {
+ result = Super.apply(this, arguments);
+ }
+
+ return possibleConstructorReturn(this, result);
+ };
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/decorate.js b/node_modules/@babel/runtime/helpers/esm/decorate.js
new file mode 100644
index 000000000..daf56da20
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/decorate.js
@@ -0,0 +1,396 @@
+import toArray from "./toArray.js";
+import toPropertyKey from "./toPropertyKey.js";
+export default function _decorate(decorators, factory, superClass, mixins) {
+ var api = _getDecoratorsApi();
+
+ if (mixins) {
+ for (var i = 0; i < mixins.length; i++) {
+ api = mixins[i](api);
+ }
+ }
+
+ var r = factory(function initialize(O) {
+ api.initializeInstanceElements(O, decorated.elements);
+ }, superClass);
+ var decorated = api.decorateClass(_coalesceClassElements(r.d.map(_createElementDescriptor)), decorators);
+ api.initializeClassElements(r.F, decorated.elements);
+ return api.runClassFinishers(r.F, decorated.finishers);
+}
+
+function _getDecoratorsApi() {
+ _getDecoratorsApi = function _getDecoratorsApi() {
+ return api;
+ };
+
+ var api = {
+ elementsDefinitionOrder: [["method"], ["field"]],
+ initializeInstanceElements: function initializeInstanceElements(O, elements) {
+ ["method", "field"].forEach(function (kind) {
+ elements.forEach(function (element) {
+ if (element.kind === kind && element.placement === "own") {
+ this.defineClassElement(O, element);
+ }
+ }, this);
+ }, this);
+ },
+ initializeClassElements: function initializeClassElements(F, elements) {
+ var proto = F.prototype;
+ ["method", "field"].forEach(function (kind) {
+ elements.forEach(function (element) {
+ var placement = element.placement;
+
+ if (element.kind === kind && (placement === "static" || placement === "prototype")) {
+ var receiver = placement === "static" ? F : proto;
+ this.defineClassElement(receiver, element);
+ }
+ }, this);
+ }, this);
+ },
+ defineClassElement: function defineClassElement(receiver, element) {
+ var descriptor = element.descriptor;
+
+ if (element.kind === "field") {
+ var initializer = element.initializer;
+ descriptor = {
+ enumerable: descriptor.enumerable,
+ writable: descriptor.writable,
+ configurable: descriptor.configurable,
+ value: initializer === void 0 ? void 0 : initializer.call(receiver)
+ };
+ }
+
+ Object.defineProperty(receiver, element.key, descriptor);
+ },
+ decorateClass: function decorateClass(elements, decorators) {
+ var newElements = [];
+ var finishers = [];
+ var placements = {
+ "static": [],
+ prototype: [],
+ own: []
+ };
+ elements.forEach(function (element) {
+ this.addElementPlacement(element, placements);
+ }, this);
+ elements.forEach(function (element) {
+ if (!_hasDecorators(element)) return newElements.push(element);
+ var elementFinishersExtras = this.decorateElement(element, placements);
+ newElements.push(elementFinishersExtras.element);
+ newElements.push.apply(newElements, elementFinishersExtras.extras);
+ finishers.push.apply(finishers, elementFinishersExtras.finishers);
+ }, this);
+
+ if (!decorators) {
+ return {
+ elements: newElements,
+ finishers: finishers
+ };
+ }
+
+ var result = this.decorateConstructor(newElements, decorators);
+ finishers.push.apply(finishers, result.finishers);
+ result.finishers = finishers;
+ return result;
+ },
+ addElementPlacement: function addElementPlacement(element, placements, silent) {
+ var keys = placements[element.placement];
+
+ if (!silent && keys.indexOf(element.key) !== -1) {
+ throw new TypeError("Duplicated element (" + element.key + ")");
+ }
+
+ keys.push(element.key);
+ },
+ decorateElement: function decorateElement(element, placements) {
+ var extras = [];
+ var finishers = [];
+
+ for (var decorators = element.decorators, i = decorators.length - 1; i >= 0; i--) {
+ var keys = placements[element.placement];
+ keys.splice(keys.indexOf(element.key), 1);
+ var elementObject = this.fromElementDescriptor(element);
+ var elementFinisherExtras = this.toElementFinisherExtras((0, decorators[i])(elementObject) || elementObject);
+ element = elementFinisherExtras.element;
+ this.addElementPlacement(element, placements);
+
+ if (elementFinisherExtras.finisher) {
+ finishers.push(elementFinisherExtras.finisher);
+ }
+
+ var newExtras = elementFinisherExtras.extras;
+
+ if (newExtras) {
+ for (var j = 0; j < newExtras.length; j++) {
+ this.addElementPlacement(newExtras[j], placements);
+ }
+
+ extras.push.apply(extras, newExtras);
+ }
+ }
+
+ return {
+ element: element,
+ finishers: finishers,
+ extras: extras
+ };
+ },
+ decorateConstructor: function decorateConstructor(elements, decorators) {
+ var finishers = [];
+
+ for (var i = decorators.length - 1; i >= 0; i--) {
+ var obj = this.fromClassDescriptor(elements);
+ var elementsAndFinisher = this.toClassDescriptor((0, decorators[i])(obj) || obj);
+
+ if (elementsAndFinisher.finisher !== undefined) {
+ finishers.push(elementsAndFinisher.finisher);
+ }
+
+ if (elementsAndFinisher.elements !== undefined) {
+ elements = elementsAndFinisher.elements;
+
+ for (var j = 0; j < elements.length - 1; j++) {
+ for (var k = j + 1; k < elements.length; k++) {
+ if (elements[j].key === elements[k].key && elements[j].placement === elements[k].placement) {
+ throw new TypeError("Duplicated element (" + elements[j].key + ")");
+ }
+ }
+ }
+ }
+ }
+
+ return {
+ elements: elements,
+ finishers: finishers
+ };
+ },
+ fromElementDescriptor: function fromElementDescriptor(element) {
+ var obj = {
+ kind: element.kind,
+ key: element.key,
+ placement: element.placement,
+ descriptor: element.descriptor
+ };
+ var desc = {
+ value: "Descriptor",
+ configurable: true
+ };
+ Object.defineProperty(obj, Symbol.toStringTag, desc);
+ if (element.kind === "field") obj.initializer = element.initializer;
+ return obj;
+ },
+ toElementDescriptors: function toElementDescriptors(elementObjects) {
+ if (elementObjects === undefined) return;
+ return toArray(elementObjects).map(function (elementObject) {
+ var element = this.toElementDescriptor(elementObject);
+ this.disallowProperty(elementObject, "finisher", "An element descriptor");
+ this.disallowProperty(elementObject, "extras", "An element descriptor");
+ return element;
+ }, this);
+ },
+ toElementDescriptor: function toElementDescriptor(elementObject) {
+ var kind = String(elementObject.kind);
+
+ if (kind !== "method" && kind !== "field") {
+ throw new TypeError('An element descriptor\'s .kind property must be either "method" or' + ' "field", but a decorator created an element descriptor with' + ' .kind "' + kind + '"');
+ }
+
+ var key = toPropertyKey(elementObject.key);
+ var placement = String(elementObject.placement);
+
+ if (placement !== "static" && placement !== "prototype" && placement !== "own") {
+ throw new TypeError('An element descriptor\'s .placement property must be one of "static",' + ' "prototype" or "own", but a decorator created an element descriptor' + ' with .placement "' + placement + '"');
+ }
+
+ var descriptor = elementObject.descriptor;
+ this.disallowProperty(elementObject, "elements", "An element descriptor");
+ var element = {
+ kind: kind,
+ key: key,
+ placement: placement,
+ descriptor: Object.assign({}, descriptor)
+ };
+
+ if (kind !== "field") {
+ this.disallowProperty(elementObject, "initializer", "A method descriptor");
+ } else {
+ this.disallowProperty(descriptor, "get", "The property descriptor of a field descriptor");
+ this.disallowProperty(descriptor, "set", "The property descriptor of a field descriptor");
+ this.disallowProperty(descriptor, "value", "The property descriptor of a field descriptor");
+ element.initializer = elementObject.initializer;
+ }
+
+ return element;
+ },
+ toElementFinisherExtras: function toElementFinisherExtras(elementObject) {
+ var element = this.toElementDescriptor(elementObject);
+
+ var finisher = _optionalCallableProperty(elementObject, "finisher");
+
+ var extras = this.toElementDescriptors(elementObject.extras);
+ return {
+ element: element,
+ finisher: finisher,
+ extras: extras
+ };
+ },
+ fromClassDescriptor: function fromClassDescriptor(elements) {
+ var obj = {
+ kind: "class",
+ elements: elements.map(this.fromElementDescriptor, this)
+ };
+ var desc = {
+ value: "Descriptor",
+ configurable: true
+ };
+ Object.defineProperty(obj, Symbol.toStringTag, desc);
+ return obj;
+ },
+ toClassDescriptor: function toClassDescriptor(obj) {
+ var kind = String(obj.kind);
+
+ if (kind !== "class") {
+ throw new TypeError('A class descriptor\'s .kind property must be "class", but a decorator' + ' created a class descriptor with .kind "' + kind + '"');
+ }
+
+ this.disallowProperty(obj, "key", "A class descriptor");
+ this.disallowProperty(obj, "placement", "A class descriptor");
+ this.disallowProperty(obj, "descriptor", "A class descriptor");
+ this.disallowProperty(obj, "initializer", "A class descriptor");
+ this.disallowProperty(obj, "extras", "A class descriptor");
+
+ var finisher = _optionalCallableProperty(obj, "finisher");
+
+ var elements = this.toElementDescriptors(obj.elements);
+ return {
+ elements: elements,
+ finisher: finisher
+ };
+ },
+ runClassFinishers: function runClassFinishers(constructor, finishers) {
+ for (var i = 0; i < finishers.length; i++) {
+ var newConstructor = (0, finishers[i])(constructor);
+
+ if (newConstructor !== undefined) {
+ if (typeof newConstructor !== "function") {
+ throw new TypeError("Finishers must return a constructor.");
+ }
+
+ constructor = newConstructor;
+ }
+ }
+
+ return constructor;
+ },
+ disallowProperty: function disallowProperty(obj, name, objectType) {
+ if (obj[name] !== undefined) {
+ throw new TypeError(objectType + " can't have a ." + name + " property.");
+ }
+ }
+ };
+ return api;
+}
+
+function _createElementDescriptor(def) {
+ var key = toPropertyKey(def.key);
+ var descriptor;
+
+ if (def.kind === "method") {
+ descriptor = {
+ value: def.value,
+ writable: true,
+ configurable: true,
+ enumerable: false
+ };
+ } else if (def.kind === "get") {
+ descriptor = {
+ get: def.value,
+ configurable: true,
+ enumerable: false
+ };
+ } else if (def.kind === "set") {
+ descriptor = {
+ set: def.value,
+ configurable: true,
+ enumerable: false
+ };
+ } else if (def.kind === "field") {
+ descriptor = {
+ configurable: true,
+ writable: true,
+ enumerable: true
+ };
+ }
+
+ var element = {
+ kind: def.kind === "field" ? "field" : "method",
+ key: key,
+ placement: def["static"] ? "static" : def.kind === "field" ? "own" : "prototype",
+ descriptor: descriptor
+ };
+ if (def.decorators) element.decorators = def.decorators;
+ if (def.kind === "field") element.initializer = def.value;
+ return element;
+}
+
+function _coalesceGetterSetter(element, other) {
+ if (element.descriptor.get !== undefined) {
+ other.descriptor.get = element.descriptor.get;
+ } else {
+ other.descriptor.set = element.descriptor.set;
+ }
+}
+
+function _coalesceClassElements(elements) {
+ var newElements = [];
+
+ var isSameElement = function isSameElement(other) {
+ return other.kind === "method" && other.key === element.key && other.placement === element.placement;
+ };
+
+ for (var i = 0; i < elements.length; i++) {
+ var element = elements[i];
+ var other;
+
+ if (element.kind === "method" && (other = newElements.find(isSameElement))) {
+ if (_isDataDescriptor(element.descriptor) || _isDataDescriptor(other.descriptor)) {
+ if (_hasDecorators(element) || _hasDecorators(other)) {
+ throw new ReferenceError("Duplicated methods (" + element.key + ") can't be decorated.");
+ }
+
+ other.descriptor = element.descriptor;
+ } else {
+ if (_hasDecorators(element)) {
+ if (_hasDecorators(other)) {
+ throw new ReferenceError("Decorators can't be placed on different accessors with for " + "the same property (" + element.key + ").");
+ }
+
+ other.decorators = element.decorators;
+ }
+
+ _coalesceGetterSetter(element, other);
+ }
+ } else {
+ newElements.push(element);
+ }
+ }
+
+ return newElements;
+}
+
+function _hasDecorators(element) {
+ return element.decorators && element.decorators.length;
+}
+
+function _isDataDescriptor(desc) {
+ return desc !== undefined && !(desc.value === undefined && desc.writable === undefined);
+}
+
+function _optionalCallableProperty(obj, name) {
+ var value = obj[name];
+
+ if (value !== undefined && typeof value !== "function") {
+ throw new TypeError("Expected '" + name + "' to be a function");
+ }
+
+ return value;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/defaults.js b/node_modules/@babel/runtime/helpers/esm/defaults.js
new file mode 100644
index 000000000..3de1d8ecf
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/defaults.js
@@ -0,0 +1,14 @@
+export default function _defaults(obj, defaults) {
+ var keys = Object.getOwnPropertyNames(defaults);
+
+ for (var i = 0; i < keys.length; i++) {
+ var key = keys[i];
+ var value = Object.getOwnPropertyDescriptor(defaults, key);
+
+ if (value && value.configurable && obj[key] === undefined) {
+ Object.defineProperty(obj, key, value);
+ }
+ }
+
+ return obj;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/defineEnumerableProperties.js b/node_modules/@babel/runtime/helpers/esm/defineEnumerableProperties.js
new file mode 100644
index 000000000..7981acd48
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/defineEnumerableProperties.js
@@ -0,0 +1,22 @@
+export default function _defineEnumerableProperties(obj, descs) {
+ for (var key in descs) {
+ var desc = descs[key];
+ desc.configurable = desc.enumerable = true;
+ if ("value" in desc) desc.writable = true;
+ Object.defineProperty(obj, key, desc);
+ }
+
+ if (Object.getOwnPropertySymbols) {
+ var objectSymbols = Object.getOwnPropertySymbols(descs);
+
+ for (var i = 0; i < objectSymbols.length; i++) {
+ var sym = objectSymbols[i];
+ var desc = descs[sym];
+ desc.configurable = desc.enumerable = true;
+ if ("value" in desc) desc.writable = true;
+ Object.defineProperty(obj, sym, desc);
+ }
+ }
+
+ return obj;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/defineProperty.js b/node_modules/@babel/runtime/helpers/esm/defineProperty.js
new file mode 100644
index 000000000..7cf6e59fd
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/defineProperty.js
@@ -0,0 +1,14 @@
+export default function _defineProperty(obj, key, value) {
+ if (key in obj) {
+ Object.defineProperty(obj, key, {
+ value: value,
+ enumerable: true,
+ configurable: true,
+ writable: true
+ });
+ } else {
+ obj[key] = value;
+ }
+
+ return obj;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/extends.js b/node_modules/@babel/runtime/helpers/esm/extends.js
new file mode 100644
index 000000000..b9b138d82
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/extends.js
@@ -0,0 +1,17 @@
+export default function _extends() {
+ _extends = Object.assign || function (target) {
+ for (var i = 1; i < arguments.length; i++) {
+ var source = arguments[i];
+
+ for (var key in source) {
+ if (Object.prototype.hasOwnProperty.call(source, key)) {
+ target[key] = source[key];
+ }
+ }
+ }
+
+ return target;
+ };
+
+ return _extends.apply(this, arguments);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/get.js b/node_modules/@babel/runtime/helpers/esm/get.js
new file mode 100644
index 000000000..92038bd13
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/get.js
@@ -0,0 +1,20 @@
+import superPropBase from "./superPropBase.js";
+export default function _get() {
+ if (typeof Reflect !== "undefined" && Reflect.get) {
+ _get = Reflect.get;
+ } else {
+ _get = function _get(target, property, receiver) {
+ var base = superPropBase(target, property);
+ if (!base) return;
+ var desc = Object.getOwnPropertyDescriptor(base, property);
+
+ if (desc.get) {
+ return desc.get.call(arguments.length < 3 ? target : receiver);
+ }
+
+ return desc.value;
+ };
+ }
+
+ return _get.apply(this, arguments);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/getPrototypeOf.js b/node_modules/@babel/runtime/helpers/esm/getPrototypeOf.js
new file mode 100644
index 000000000..5abafe381
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/getPrototypeOf.js
@@ -0,0 +1,6 @@
+export default function _getPrototypeOf(o) {
+ _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
+ return o.__proto__ || Object.getPrototypeOf(o);
+ };
+ return _getPrototypeOf(o);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/identity.js b/node_modules/@babel/runtime/helpers/esm/identity.js
new file mode 100644
index 000000000..a1e7e4cda
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/identity.js
@@ -0,0 +1,3 @@
+export default function _identity(x) {
+ return x;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/inherits.js b/node_modules/@babel/runtime/helpers/esm/inherits.js
new file mode 100644
index 000000000..e099909fd
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/inherits.js
@@ -0,0 +1,18 @@
+import setPrototypeOf from "./setPrototypeOf.js";
+export default function _inherits(subClass, superClass) {
+ if (typeof superClass !== "function" && superClass !== null) {
+ throw new TypeError("Super expression must either be null or a function");
+ }
+
+ subClass.prototype = Object.create(superClass && superClass.prototype, {
+ constructor: {
+ value: subClass,
+ writable: true,
+ configurable: true
+ }
+ });
+ Object.defineProperty(subClass, "prototype", {
+ writable: false
+ });
+ if (superClass) setPrototypeOf(subClass, superClass);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/inheritsLoose.js b/node_modules/@babel/runtime/helpers/esm/inheritsLoose.js
new file mode 100644
index 000000000..90bb79657
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/inheritsLoose.js
@@ -0,0 +1,6 @@
+import setPrototypeOf from "./setPrototypeOf.js";
+export default function _inheritsLoose(subClass, superClass) {
+ subClass.prototype = Object.create(superClass.prototype);
+ subClass.prototype.constructor = subClass;
+ setPrototypeOf(subClass, superClass);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/initializerDefineProperty.js b/node_modules/@babel/runtime/helpers/esm/initializerDefineProperty.js
new file mode 100644
index 000000000..26fdea084
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/initializerDefineProperty.js
@@ -0,0 +1,9 @@
+export default function _initializerDefineProperty(target, property, descriptor, context) {
+ if (!descriptor) return;
+ Object.defineProperty(target, property, {
+ enumerable: descriptor.enumerable,
+ configurable: descriptor.configurable,
+ writable: descriptor.writable,
+ value: descriptor.initializer ? descriptor.initializer.call(context) : void 0
+ });
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/initializerWarningHelper.js b/node_modules/@babel/runtime/helpers/esm/initializerWarningHelper.js
new file mode 100644
index 000000000..30d518cfd
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/initializerWarningHelper.js
@@ -0,0 +1,3 @@
+export default function _initializerWarningHelper(descriptor, context) {
+ throw new Error('Decorating class property failed. Please ensure that ' + 'proposal-class-properties is enabled and runs after the decorators transform.');
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/instanceof.js b/node_modules/@babel/runtime/helpers/esm/instanceof.js
new file mode 100644
index 000000000..8c43b7178
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/instanceof.js
@@ -0,0 +1,7 @@
+export default function _instanceof(left, right) {
+ if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+ return !!right[Symbol.hasInstance](left);
+ } else {
+ return left instanceof right;
+ }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/interopRequireDefault.js b/node_modules/@babel/runtime/helpers/esm/interopRequireDefault.js
new file mode 100644
index 000000000..c2df7b641
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/interopRequireDefault.js
@@ -0,0 +1,5 @@
+export default function _interopRequireDefault(obj) {
+ return obj && obj.__esModule ? obj : {
+ "default": obj
+ };
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/interopRequireWildcard.js b/node_modules/@babel/runtime/helpers/esm/interopRequireWildcard.js
new file mode 100644
index 000000000..01ee6b3fe
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/interopRequireWildcard.js
@@ -0,0 +1,51 @@
+import _typeof from "./typeof.js";
+
+function _getRequireWildcardCache(nodeInterop) {
+ if (typeof WeakMap !== "function") return null;
+ var cacheBabelInterop = new WeakMap();
+ var cacheNodeInterop = new WeakMap();
+ return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) {
+ return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+ })(nodeInterop);
+}
+
+export default function _interopRequireWildcard(obj, nodeInterop) {
+ if (!nodeInterop && obj && obj.__esModule) {
+ return obj;
+ }
+
+ if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") {
+ return {
+ "default": obj
+ };
+ }
+
+ var cache = _getRequireWildcardCache(nodeInterop);
+
+ if (cache && cache.has(obj)) {
+ return cache.get(obj);
+ }
+
+ var newObj = {};
+ var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+
+ for (var key in obj) {
+ if (key !== "default" && 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;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/isNativeFunction.js b/node_modules/@babel/runtime/helpers/esm/isNativeFunction.js
new file mode 100644
index 000000000..7b1bc821f
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/isNativeFunction.js
@@ -0,0 +1,3 @@
+export default function _isNativeFunction(fn) {
+ return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/isNativeReflectConstruct.js b/node_modules/@babel/runtime/helpers/esm/isNativeReflectConstruct.js
new file mode 100644
index 000000000..0da1624ec
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/isNativeReflectConstruct.js
@@ -0,0 +1,12 @@
+export default function _isNativeReflectConstruct() {
+ if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+ if (Reflect.construct.sham) return false;
+ if (typeof Proxy === "function") return true;
+
+ try {
+ Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+ return true;
+ } catch (e) {
+ return false;
+ }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/iterableToArray.js b/node_modules/@babel/runtime/helpers/esm/iterableToArray.js
new file mode 100644
index 000000000..cfe9fbd3b
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/iterableToArray.js
@@ -0,0 +1,3 @@
+export default function _iterableToArray(iter) {
+ if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js b/node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js
new file mode 100644
index 000000000..c72ca94b7
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js
@@ -0,0 +1,29 @@
+export default function _iterableToArrayLimit(arr, i) {
+ var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+
+ if (_i == null) return;
+ var _arr = [];
+ var _n = true;
+ var _d = false;
+
+ var _s, _e;
+
+ try {
+ for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
+ _arr.push(_s.value);
+
+ if (i && _arr.length === i) break;
+ }
+ } catch (err) {
+ _d = true;
+ _e = err;
+ } finally {
+ try {
+ if (!_n && _i["return"] != null) _i["return"]();
+ } finally {
+ if (_d) throw _e;
+ }
+ }
+
+ return _arr;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/iterableToArrayLimitLoose.js b/node_modules/@babel/runtime/helpers/esm/iterableToArrayLimitLoose.js
new file mode 100644
index 000000000..27c15e098
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/iterableToArrayLimitLoose.js
@@ -0,0 +1,14 @@
+export default function _iterableToArrayLimitLoose(arr, i) {
+ var _i = arr && (typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]);
+
+ if (_i == null) return;
+ var _arr = [];
+
+ for (_i = _i.call(arr), _step; !(_step = _i.next()).done;) {
+ _arr.push(_step.value);
+
+ if (i && _arr.length === i) break;
+ }
+
+ return _arr;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/jsx.js b/node_modules/@babel/runtime/helpers/esm/jsx.js
new file mode 100644
index 000000000..9a6a94caf
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/jsx.js
@@ -0,0 +1,26 @@
+var REACT_ELEMENT_TYPE;
+export default function _createRawReactElement(type, props, key, children) {
+ REACT_ELEMENT_TYPE || (REACT_ELEMENT_TYPE = "function" == typeof Symbol && Symbol["for"] && Symbol["for"]("react.element") || 60103);
+ var defaultProps = type && type.defaultProps,
+ childrenLength = arguments.length - 3;
+ if (props || 0 === childrenLength || (props = {
+ children: void 0
+ }), 1 === childrenLength) props.children = children;else if (childrenLength > 1) {
+ for (var childArray = new Array(childrenLength), i = 0; i < childrenLength; i++) {
+ childArray[i] = arguments[i + 3];
+ }
+
+ props.children = childArray;
+ }
+ if (props && defaultProps) for (var propName in defaultProps) {
+ void 0 === props[propName] && (props[propName] = defaultProps[propName]);
+ } else props || (props = defaultProps || {});
+ return {
+ $$typeof: REACT_ELEMENT_TYPE,
+ type: type,
+ key: void 0 === key ? null : "" + key,
+ ref: null,
+ props: props,
+ _owner: null
+ };
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/maybeArrayLike.js b/node_modules/@babel/runtime/helpers/esm/maybeArrayLike.js
new file mode 100644
index 000000000..f68795926
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/maybeArrayLike.js
@@ -0,0 +1,9 @@
+import arrayLikeToArray from "./arrayLikeToArray.js";
+export default function _maybeArrayLike(next, arr, i) {
+ if (arr && !Array.isArray(arr) && typeof arr.length === "number") {
+ var len = arr.length;
+ return arrayLikeToArray(arr, i !== void 0 && i < len ? i : len);
+ }
+
+ return next(arr, i);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/newArrowCheck.js b/node_modules/@babel/runtime/helpers/esm/newArrowCheck.js
new file mode 100644
index 000000000..d6cd86437
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/newArrowCheck.js
@@ -0,0 +1,5 @@
+export default function _newArrowCheck(innerThis, boundThis) {
+ if (innerThis !== boundThis) {
+ throw new TypeError("Cannot instantiate an arrow function");
+ }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/nonIterableRest.js b/node_modules/@babel/runtime/helpers/esm/nonIterableRest.js
new file mode 100644
index 000000000..b349d006c
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/nonIterableRest.js
@@ -0,0 +1,3 @@
+export default function _nonIterableRest() {
+ throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/nonIterableSpread.js b/node_modules/@babel/runtime/helpers/esm/nonIterableSpread.js
new file mode 100644
index 000000000..82d829614
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/nonIterableSpread.js
@@ -0,0 +1,3 @@
+export default function _nonIterableSpread() {
+ throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/objectDestructuringEmpty.js b/node_modules/@babel/runtime/helpers/esm/objectDestructuringEmpty.js
new file mode 100644
index 000000000..82b67d2cb
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/objectDestructuringEmpty.js
@@ -0,0 +1,3 @@
+export default function _objectDestructuringEmpty(obj) {
+ if (obj == null) throw new TypeError("Cannot destructure undefined");
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/objectSpread.js b/node_modules/@babel/runtime/helpers/esm/objectSpread.js
new file mode 100644
index 000000000..889a5f0e4
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/objectSpread.js
@@ -0,0 +1,19 @@
+import defineProperty from "./defineProperty.js";
+export default function _objectSpread(target) {
+ for (var i = 1; i < arguments.length; i++) {
+ var source = arguments[i] != null ? Object(arguments[i]) : {};
+ var ownKeys = Object.keys(source);
+
+ if (typeof Object.getOwnPropertySymbols === 'function') {
+ ownKeys.push.apply(ownKeys, Object.getOwnPropertySymbols(source).filter(function (sym) {
+ return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+ }));
+ }
+
+ ownKeys.forEach(function (key) {
+ defineProperty(target, key, source[key]);
+ });
+ }
+
+ return target;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/objectSpread2.js b/node_modules/@babel/runtime/helpers/esm/objectSpread2.js
new file mode 100644
index 000000000..76f296887
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/objectSpread2.js
@@ -0,0 +1,27 @@
+import defineProperty from "./defineProperty.js";
+
+function ownKeys(object, enumerableOnly) {
+ var keys = Object.keys(object);
+
+ if (Object.getOwnPropertySymbols) {
+ var symbols = Object.getOwnPropertySymbols(object);
+ enumerableOnly && (symbols = symbols.filter(function (sym) {
+ return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+ })), keys.push.apply(keys, symbols);
+ }
+
+ return keys;
+}
+
+export default function _objectSpread2(target) {
+ for (var i = 1; i < arguments.length; i++) {
+ var source = null != arguments[i] ? arguments[i] : {};
+ i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {
+ defineProperty(target, key, source[key]);
+ }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {
+ Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+ });
+ }
+
+ return target;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/objectWithoutProperties.js b/node_modules/@babel/runtime/helpers/esm/objectWithoutProperties.js
new file mode 100644
index 000000000..0fef32192
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/objectWithoutProperties.js
@@ -0,0 +1,19 @@
+import objectWithoutPropertiesLoose from "./objectWithoutPropertiesLoose.js";
+export default function _objectWithoutProperties(source, excluded) {
+ if (source == null) return {};
+ var target = objectWithoutPropertiesLoose(source, excluded);
+ var key, i;
+
+ if (Object.getOwnPropertySymbols) {
+ var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+
+ for (i = 0; i < sourceSymbolKeys.length; i++) {
+ key = sourceSymbolKeys[i];
+ if (excluded.indexOf(key) >= 0) continue;
+ if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+ target[key] = source[key];
+ }
+ }
+
+ return target;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js b/node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js
new file mode 100644
index 000000000..c36815ceb
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js
@@ -0,0 +1,14 @@
+export default function _objectWithoutPropertiesLoose(source, excluded) {
+ if (source == null) return {};
+ var target = {};
+ var sourceKeys = Object.keys(source);
+ var key, i;
+
+ for (i = 0; i < sourceKeys.length; i++) {
+ key = sourceKeys[i];
+ if (excluded.indexOf(key) >= 0) continue;
+ target[key] = source[key];
+ }
+
+ return target;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/package.json b/node_modules/@babel/runtime/helpers/esm/package.json
new file mode 100644
index 000000000..aead43de3
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/package.json
@@ -0,0 +1,3 @@
+{
+ "type": "module"
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/possibleConstructorReturn.js b/node_modules/@babel/runtime/helpers/esm/possibleConstructorReturn.js
new file mode 100644
index 000000000..56d554457
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/possibleConstructorReturn.js
@@ -0,0 +1,11 @@
+import _typeof from "./typeof.js";
+import assertThisInitialized from "./assertThisInitialized.js";
+export default function _possibleConstructorReturn(self, call) {
+ if (call && (_typeof(call) === "object" || typeof call === "function")) {
+ return call;
+ } else if (call !== void 0) {
+ throw new TypeError("Derived constructors may only return object or undefined");
+ }
+
+ return assertThisInitialized(self);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/readOnlyError.js b/node_modules/@babel/runtime/helpers/esm/readOnlyError.js
new file mode 100644
index 000000000..166e40e5e
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/readOnlyError.js
@@ -0,0 +1,3 @@
+export default function _readOnlyError(name) {
+ throw new TypeError("\"" + name + "\" is read-only");
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/set.js b/node_modules/@babel/runtime/helpers/esm/set.js
new file mode 100644
index 000000000..9c5477390
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/set.js
@@ -0,0 +1,51 @@
+import superPropBase from "./superPropBase.js";
+import defineProperty from "./defineProperty.js";
+
+function set(target, property, value, receiver) {
+ if (typeof Reflect !== "undefined" && Reflect.set) {
+ set = Reflect.set;
+ } else {
+ set = function set(target, property, value, receiver) {
+ var base = superPropBase(target, property);
+ var desc;
+
+ if (base) {
+ desc = Object.getOwnPropertyDescriptor(base, property);
+
+ if (desc.set) {
+ desc.set.call(receiver, value);
+ return true;
+ } else if (!desc.writable) {
+ return false;
+ }
+ }
+
+ desc = Object.getOwnPropertyDescriptor(receiver, property);
+
+ if (desc) {
+ if (!desc.writable) {
+ return false;
+ }
+
+ desc.value = value;
+ Object.defineProperty(receiver, property, desc);
+ } else {
+ defineProperty(receiver, property, value);
+ }
+
+ return true;
+ };
+ }
+
+ return set(target, property, value, receiver);
+}
+
+export default function _set(target, property, value, receiver, isStrict) {
+ var s = set(target, property, value, receiver || target);
+
+ if (!s && isStrict) {
+ throw new Error('failed to set property');
+ }
+
+ return value;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/setPrototypeOf.js b/node_modules/@babel/runtime/helpers/esm/setPrototypeOf.js
new file mode 100644
index 000000000..e6ef03e59
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/setPrototypeOf.js
@@ -0,0 +1,8 @@
+export default function _setPrototypeOf(o, p) {
+ _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+ o.__proto__ = p;
+ return o;
+ };
+
+ return _setPrototypeOf(o, p);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/skipFirstGeneratorNext.js b/node_modules/@babel/runtime/helpers/esm/skipFirstGeneratorNext.js
new file mode 100644
index 000000000..cadd9bb5b
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/skipFirstGeneratorNext.js
@@ -0,0 +1,7 @@
+export default function _skipFirstGeneratorNext(fn) {
+ return function () {
+ var it = fn.apply(this, arguments);
+ it.next();
+ return it;
+ };
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/slicedToArray.js b/node_modules/@babel/runtime/helpers/esm/slicedToArray.js
new file mode 100644
index 000000000..618200b92
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/slicedToArray.js
@@ -0,0 +1,7 @@
+import arrayWithHoles from "./arrayWithHoles.js";
+import iterableToArrayLimit from "./iterableToArrayLimit.js";
+import unsupportedIterableToArray from "./unsupportedIterableToArray.js";
+import nonIterableRest from "./nonIterableRest.js";
+export default function _slicedToArray(arr, i) {
+ return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/slicedToArrayLoose.js b/node_modules/@babel/runtime/helpers/esm/slicedToArrayLoose.js
new file mode 100644
index 000000000..efc7429ef
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/slicedToArrayLoose.js
@@ -0,0 +1,7 @@
+import arrayWithHoles from "./arrayWithHoles.js";
+import iterableToArrayLimitLoose from "./iterableToArrayLimitLoose.js";
+import unsupportedIterableToArray from "./unsupportedIterableToArray.js";
+import nonIterableRest from "./nonIterableRest.js";
+export default function _slicedToArrayLoose(arr, i) {
+ return arrayWithHoles(arr) || iterableToArrayLimitLoose(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/superPropBase.js b/node_modules/@babel/runtime/helpers/esm/superPropBase.js
new file mode 100644
index 000000000..feffe6f7e
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/superPropBase.js
@@ -0,0 +1,9 @@
+import getPrototypeOf from "./getPrototypeOf.js";
+export default function _superPropBase(object, property) {
+ while (!Object.prototype.hasOwnProperty.call(object, property)) {
+ object = getPrototypeOf(object);
+ if (object === null) break;
+ }
+
+ return object;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/taggedTemplateLiteral.js b/node_modules/@babel/runtime/helpers/esm/taggedTemplateLiteral.js
new file mode 100644
index 000000000..421f18abd
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/taggedTemplateLiteral.js
@@ -0,0 +1,11 @@
+export default function _taggedTemplateLiteral(strings, raw) {
+ if (!raw) {
+ raw = strings.slice(0);
+ }
+
+ return Object.freeze(Object.defineProperties(strings, {
+ raw: {
+ value: Object.freeze(raw)
+ }
+ }));
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/taggedTemplateLiteralLoose.js b/node_modules/@babel/runtime/helpers/esm/taggedTemplateLiteralLoose.js
new file mode 100644
index 000000000..c8f081e9e
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/taggedTemplateLiteralLoose.js
@@ -0,0 +1,8 @@
+export default function _taggedTemplateLiteralLoose(strings, raw) {
+ if (!raw) {
+ raw = strings.slice(0);
+ }
+
+ strings.raw = raw;
+ return strings;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/tdz.js b/node_modules/@babel/runtime/helpers/esm/tdz.js
new file mode 100644
index 000000000..d5d0adc8a
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/tdz.js
@@ -0,0 +1,3 @@
+export default function _tdzError(name) {
+ throw new ReferenceError(name + " is not defined - temporal dead zone");
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/temporalRef.js b/node_modules/@babel/runtime/helpers/esm/temporalRef.js
new file mode 100644
index 000000000..b25f7c44f
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/temporalRef.js
@@ -0,0 +1,5 @@
+import undef from "./temporalUndefined.js";
+import err from "./tdz.js";
+export default function _temporalRef(val, name) {
+ return val === undef ? err(name) : val;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/temporalUndefined.js b/node_modules/@babel/runtime/helpers/esm/temporalUndefined.js
new file mode 100644
index 000000000..1a3571734
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/temporalUndefined.js
@@ -0,0 +1 @@
+export default function _temporalUndefined() {}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/toArray.js b/node_modules/@babel/runtime/helpers/esm/toArray.js
new file mode 100644
index 000000000..ad7c871a5
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/toArray.js
@@ -0,0 +1,7 @@
+import arrayWithHoles from "./arrayWithHoles.js";
+import iterableToArray from "./iterableToArray.js";
+import unsupportedIterableToArray from "./unsupportedIterableToArray.js";
+import nonIterableRest from "./nonIterableRest.js";
+export default function _toArray(arr) {
+ return arrayWithHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableRest();
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/toConsumableArray.js b/node_modules/@babel/runtime/helpers/esm/toConsumableArray.js
new file mode 100644
index 000000000..bd9128559
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/toConsumableArray.js
@@ -0,0 +1,7 @@
+import arrayWithoutHoles from "./arrayWithoutHoles.js";
+import iterableToArray from "./iterableToArray.js";
+import unsupportedIterableToArray from "./unsupportedIterableToArray.js";
+import nonIterableSpread from "./nonIterableSpread.js";
+export default function _toConsumableArray(arr) {
+ return arrayWithoutHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableSpread();
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/toPrimitive.js b/node_modules/@babel/runtime/helpers/esm/toPrimitive.js
new file mode 100644
index 000000000..fa32ddacb
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/toPrimitive.js
@@ -0,0 +1,13 @@
+import _typeof from "./typeof.js";
+export default function _toPrimitive(input, hint) {
+ if (_typeof(input) !== "object" || input === null) return input;
+ var prim = input[Symbol.toPrimitive];
+
+ if (prim !== undefined) {
+ var res = prim.call(input, hint || "default");
+ if (_typeof(res) !== "object") return res;
+ throw new TypeError("@@toPrimitive must return a primitive value.");
+ }
+
+ return (hint === "string" ? String : Number)(input);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/toPropertyKey.js b/node_modules/@babel/runtime/helpers/esm/toPropertyKey.js
new file mode 100644
index 000000000..0fcc93b3e
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/toPropertyKey.js
@@ -0,0 +1,6 @@
+import _typeof from "./typeof.js";
+import toPrimitive from "./toPrimitive.js";
+export default function _toPropertyKey(arg) {
+ var key = toPrimitive(arg, "string");
+ return _typeof(key) === "symbol" ? key : String(key);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/typeof.js b/node_modules/@babel/runtime/helpers/esm/typeof.js
new file mode 100644
index 000000000..92100c66f
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/typeof.js
@@ -0,0 +1,9 @@
+export default function _typeof(obj) {
+ "@babel/helpers - typeof";
+
+ return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
+ return typeof obj;
+ } : function (obj) {
+ return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+ }, _typeof(obj);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js b/node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js
new file mode 100644
index 000000000..c0f63bd5a
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js
@@ -0,0 +1,9 @@
+import arrayLikeToArray from "./arrayLikeToArray.js";
+export default function _unsupportedIterableToArray(o, minLen) {
+ if (!o) return;
+ if (typeof o === "string") return arrayLikeToArray(o, minLen);
+ var n = Object.prototype.toString.call(o).slice(8, -1);
+ if (n === "Object" && o.constructor) n = o.constructor.name;
+ if (n === "Map" || n === "Set") return Array.from(o);
+ if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return arrayLikeToArray(o, minLen);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/wrapAsyncGenerator.js b/node_modules/@babel/runtime/helpers/esm/wrapAsyncGenerator.js
new file mode 100644
index 000000000..723b2ddac
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/wrapAsyncGenerator.js
@@ -0,0 +1,6 @@
+import AsyncGenerator from "./AsyncGenerator.js";
+export default function _wrapAsyncGenerator(fn) {
+ return function () {
+ return new AsyncGenerator(fn.apply(this, arguments));
+ };
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/wrapNativeSuper.js b/node_modules/@babel/runtime/helpers/esm/wrapNativeSuper.js
new file mode 100644
index 000000000..512630d0e
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/wrapNativeSuper.js
@@ -0,0 +1,37 @@
+import getPrototypeOf from "./getPrototypeOf.js";
+import setPrototypeOf from "./setPrototypeOf.js";
+import isNativeFunction from "./isNativeFunction.js";
+import construct from "./construct.js";
+export default function _wrapNativeSuper(Class) {
+ var _cache = typeof Map === "function" ? new Map() : undefined;
+
+ _wrapNativeSuper = function _wrapNativeSuper(Class) {
+ if (Class === null || !isNativeFunction(Class)) return Class;
+
+ if (typeof Class !== "function") {
+ throw new TypeError("Super expression must either be null or a function");
+ }
+
+ if (typeof _cache !== "undefined") {
+ if (_cache.has(Class)) return _cache.get(Class);
+
+ _cache.set(Class, Wrapper);
+ }
+
+ function Wrapper() {
+ return construct(Class, arguments, getPrototypeOf(this).constructor);
+ }
+
+ Wrapper.prototype = Object.create(Class.prototype, {
+ constructor: {
+ value: Wrapper,
+ enumerable: false,
+ writable: true,
+ configurable: true
+ }
+ });
+ return setPrototypeOf(Wrapper, Class);
+ };
+
+ return _wrapNativeSuper(Class);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/wrapRegExp.js b/node_modules/@babel/runtime/helpers/esm/wrapRegExp.js
new file mode 100644
index 000000000..beac1e135
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/wrapRegExp.js
@@ -0,0 +1,50 @@
+import _typeof from "./typeof.js";
+import setPrototypeOf from "./setPrototypeOf.js";
+import inherits from "./inherits.js";
+export default function _wrapRegExp() {
+ _wrapRegExp = function _wrapRegExp(re, groups) {
+ return new BabelRegExp(re, void 0, groups);
+ };
+
+ var _super = RegExp.prototype,
+ _groups = new WeakMap();
+
+ function BabelRegExp(re, flags, groups) {
+ var _this = new RegExp(re, flags);
+
+ return _groups.set(_this, groups || _groups.get(re)), setPrototypeOf(_this, BabelRegExp.prototype);
+ }
+
+ function buildGroups(result, re) {
+ var g = _groups.get(re);
+
+ return Object.keys(g).reduce(function (groups, name) {
+ return groups[name] = result[g[name]], groups;
+ }, Object.create(null));
+ }
+
+ return inherits(BabelRegExp, RegExp), BabelRegExp.prototype.exec = function (str) {
+ var result = _super.exec.call(this, str);
+
+ return result && (result.groups = buildGroups(result, this)), result;
+ }, BabelRegExp.prototype[Symbol.replace] = function (str, substitution) {
+ if ("string" == typeof substitution) {
+ var groups = _groups.get(this);
+
+ return _super[Symbol.replace].call(this, str, substitution.replace(/\$<([^>]+)>/g, function (_, name) {
+ return "$" + groups[name];
+ }));
+ }
+
+ if ("function" == typeof substitution) {
+ var _this = this;
+
+ return _super[Symbol.replace].call(this, str, function () {
+ var args = arguments;
+ return "object" != _typeof(args[args.length - 1]) && (args = [].slice.call(args)).push(buildGroups(args, _this)), substitution.apply(this, args);
+ });
+ }
+
+ return _super[Symbol.replace].call(this, str, substitution);
+ }, _wrapRegExp.apply(this, arguments);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/esm/writeOnlyError.js b/node_modules/@babel/runtime/helpers/esm/writeOnlyError.js
new file mode 100644
index 000000000..9170bd45d
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/esm/writeOnlyError.js
@@ -0,0 +1,3 @@
+export default function _writeOnlyError(name) {
+ throw new TypeError("\"" + name + "\" is write-only");
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/extends.js b/node_modules/@babel/runtime/helpers/extends.js
new file mode 100644
index 000000000..e8509df1b
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/extends.js
@@ -0,0 +1,18 @@
+function _extends() {
+ module.exports = _extends = Object.assign || function (target) {
+ for (var i = 1; i < arguments.length; i++) {
+ var source = arguments[i];
+
+ for (var key in source) {
+ if (Object.prototype.hasOwnProperty.call(source, key)) {
+ target[key] = source[key];
+ }
+ }
+ }
+
+ return target;
+ }, module.exports.__esModule = true, module.exports["default"] = module.exports;
+ return _extends.apply(this, arguments);
+}
+
+module.exports = _extends, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/get.js b/node_modules/@babel/runtime/helpers/get.js
new file mode 100644
index 000000000..7ddd81bd5
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/get.js
@@ -0,0 +1,23 @@
+var superPropBase = require("./superPropBase.js");
+
+function _get() {
+ if (typeof Reflect !== "undefined" && Reflect.get) {
+ module.exports = _get = Reflect.get, module.exports.__esModule = true, module.exports["default"] = module.exports;
+ } else {
+ module.exports = _get = function _get(target, property, receiver) {
+ var base = superPropBase(target, property);
+ if (!base) return;
+ var desc = Object.getOwnPropertyDescriptor(base, property);
+
+ if (desc.get) {
+ return desc.get.call(arguments.length < 3 ? target : receiver);
+ }
+
+ return desc.value;
+ }, module.exports.__esModule = true, module.exports["default"] = module.exports;
+ }
+
+ return _get.apply(this, arguments);
+}
+
+module.exports = _get, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/getPrototypeOf.js b/node_modules/@babel/runtime/helpers/getPrototypeOf.js
new file mode 100644
index 000000000..02da5632b
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/getPrototypeOf.js
@@ -0,0 +1,8 @@
+function _getPrototypeOf(o) {
+ module.exports = _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
+ return o.__proto__ || Object.getPrototypeOf(o);
+ }, module.exports.__esModule = true, module.exports["default"] = module.exports;
+ return _getPrototypeOf(o);
+}
+
+module.exports = _getPrototypeOf, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/identity.js b/node_modules/@babel/runtime/helpers/identity.js
new file mode 100644
index 000000000..3d00062c8
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/identity.js
@@ -0,0 +1,5 @@
+function _identity(x) {
+ return x;
+}
+
+module.exports = _identity, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/inherits.js b/node_modules/@babel/runtime/helpers/inherits.js
new file mode 100644
index 000000000..0b10f28e9
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/inherits.js
@@ -0,0 +1,21 @@
+var setPrototypeOf = require("./setPrototypeOf.js");
+
+function _inherits(subClass, superClass) {
+ if (typeof superClass !== "function" && superClass !== null) {
+ throw new TypeError("Super expression must either be null or a function");
+ }
+
+ subClass.prototype = Object.create(superClass && superClass.prototype, {
+ constructor: {
+ value: subClass,
+ writable: true,
+ configurable: true
+ }
+ });
+ Object.defineProperty(subClass, "prototype", {
+ writable: false
+ });
+ if (superClass) setPrototypeOf(subClass, superClass);
+}
+
+module.exports = _inherits, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/inheritsLoose.js b/node_modules/@babel/runtime/helpers/inheritsLoose.js
new file mode 100644
index 000000000..df6de46a9
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/inheritsLoose.js
@@ -0,0 +1,9 @@
+var setPrototypeOf = require("./setPrototypeOf.js");
+
+function _inheritsLoose(subClass, superClass) {
+ subClass.prototype = Object.create(superClass.prototype);
+ subClass.prototype.constructor = subClass;
+ setPrototypeOf(subClass, superClass);
+}
+
+module.exports = _inheritsLoose, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/initializerDefineProperty.js b/node_modules/@babel/runtime/helpers/initializerDefineProperty.js
new file mode 100644
index 000000000..5a595a707
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/initializerDefineProperty.js
@@ -0,0 +1,11 @@
+function _initializerDefineProperty(target, property, descriptor, context) {
+ if (!descriptor) return;
+ Object.defineProperty(target, property, {
+ enumerable: descriptor.enumerable,
+ configurable: descriptor.configurable,
+ writable: descriptor.writable,
+ value: descriptor.initializer ? descriptor.initializer.call(context) : void 0
+ });
+}
+
+module.exports = _initializerDefineProperty, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/initializerWarningHelper.js b/node_modules/@babel/runtime/helpers/initializerWarningHelper.js
new file mode 100644
index 000000000..001d8a3ab
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/initializerWarningHelper.js
@@ -0,0 +1,5 @@
+function _initializerWarningHelper(descriptor, context) {
+ throw new Error('Decorating class property failed. Please ensure that ' + 'proposal-class-properties is enabled and runs after the decorators transform.');
+}
+
+module.exports = _initializerWarningHelper, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/instanceof.js b/node_modules/@babel/runtime/helpers/instanceof.js
new file mode 100644
index 000000000..08eea81b5
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/instanceof.js
@@ -0,0 +1,9 @@
+function _instanceof(left, right) {
+ if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+ return !!right[Symbol.hasInstance](left);
+ } else {
+ return left instanceof right;
+ }
+}
+
+module.exports = _instanceof, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/interopRequireDefault.js b/node_modules/@babel/runtime/helpers/interopRequireDefault.js
new file mode 100644
index 000000000..5faa0e46c
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/interopRequireDefault.js
@@ -0,0 +1,7 @@
+function _interopRequireDefault(obj) {
+ return obj && obj.__esModule ? obj : {
+ "default": obj
+ };
+}
+
+module.exports = _interopRequireDefault, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/interopRequireWildcard.js b/node_modules/@babel/runtime/helpers/interopRequireWildcard.js
new file mode 100644
index 000000000..0f8ffbfa5
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/interopRequireWildcard.js
@@ -0,0 +1,53 @@
+var _typeof = require("./typeof.js")["default"];
+
+function _getRequireWildcardCache(nodeInterop) {
+ if (typeof WeakMap !== "function") return null;
+ var cacheBabelInterop = new WeakMap();
+ var cacheNodeInterop = new WeakMap();
+ return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) {
+ return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+ })(nodeInterop);
+}
+
+function _interopRequireWildcard(obj, nodeInterop) {
+ if (!nodeInterop && obj && obj.__esModule) {
+ return obj;
+ }
+
+ if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") {
+ return {
+ "default": obj
+ };
+ }
+
+ var cache = _getRequireWildcardCache(nodeInterop);
+
+ if (cache && cache.has(obj)) {
+ return cache.get(obj);
+ }
+
+ var newObj = {};
+ var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+
+ for (var key in obj) {
+ if (key !== "default" && 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;
+}
+
+module.exports = _interopRequireWildcard, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/isNativeFunction.js b/node_modules/@babel/runtime/helpers/isNativeFunction.js
new file mode 100644
index 000000000..5c3d98fc3
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/isNativeFunction.js
@@ -0,0 +1,5 @@
+function _isNativeFunction(fn) {
+ return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}
+
+module.exports = _isNativeFunction, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/isNativeReflectConstruct.js b/node_modules/@babel/runtime/helpers/isNativeReflectConstruct.js
new file mode 100644
index 000000000..f07899dad
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/isNativeReflectConstruct.js
@@ -0,0 +1,14 @@
+function _isNativeReflectConstruct() {
+ if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+ if (Reflect.construct.sham) return false;
+ if (typeof Proxy === "function") return true;
+
+ try {
+ Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+ return true;
+ } catch (e) {
+ return false;
+ }
+}
+
+module.exports = _isNativeReflectConstruct, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/iterableToArray.js b/node_modules/@babel/runtime/helpers/iterableToArray.js
new file mode 100644
index 000000000..5b9038a88
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/iterableToArray.js
@@ -0,0 +1,5 @@
+function _iterableToArray(iter) {
+ if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+
+module.exports = _iterableToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/iterableToArrayLimit.js b/node_modules/@babel/runtime/helpers/iterableToArrayLimit.js
new file mode 100644
index 000000000..8d01fb31f
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/iterableToArrayLimit.js
@@ -0,0 +1,31 @@
+function _iterableToArrayLimit(arr, i) {
+ var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+
+ if (_i == null) return;
+ var _arr = [];
+ var _n = true;
+ var _d = false;
+
+ var _s, _e;
+
+ try {
+ for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
+ _arr.push(_s.value);
+
+ if (i && _arr.length === i) break;
+ }
+ } catch (err) {
+ _d = true;
+ _e = err;
+ } finally {
+ try {
+ if (!_n && _i["return"] != null) _i["return"]();
+ } finally {
+ if (_d) throw _e;
+ }
+ }
+
+ return _arr;
+}
+
+module.exports = _iterableToArrayLimit, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/iterableToArrayLimitLoose.js b/node_modules/@babel/runtime/helpers/iterableToArrayLimitLoose.js
new file mode 100644
index 000000000..bca545214
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/iterableToArrayLimitLoose.js
@@ -0,0 +1,16 @@
+function _iterableToArrayLimitLoose(arr, i) {
+ var _i = arr && (typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]);
+
+ if (_i == null) return;
+ var _arr = [];
+
+ for (_i = _i.call(arr), _step; !(_step = _i.next()).done;) {
+ _arr.push(_step.value);
+
+ if (i && _arr.length === i) break;
+ }
+
+ return _arr;
+}
+
+module.exports = _iterableToArrayLimitLoose, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/jsx.js b/node_modules/@babel/runtime/helpers/jsx.js
new file mode 100644
index 000000000..bc19ec4be
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/jsx.js
@@ -0,0 +1,29 @@
+var REACT_ELEMENT_TYPE;
+
+function _createRawReactElement(type, props, key, children) {
+ REACT_ELEMENT_TYPE || (REACT_ELEMENT_TYPE = "function" == typeof Symbol && Symbol["for"] && Symbol["for"]("react.element") || 60103);
+ var defaultProps = type && type.defaultProps,
+ childrenLength = arguments.length - 3;
+ if (props || 0 === childrenLength || (props = {
+ children: void 0
+ }), 1 === childrenLength) props.children = children;else if (childrenLength > 1) {
+ for (var childArray = new Array(childrenLength), i = 0; i < childrenLength; i++) {
+ childArray[i] = arguments[i + 3];
+ }
+
+ props.children = childArray;
+ }
+ if (props && defaultProps) for (var propName in defaultProps) {
+ void 0 === props[propName] && (props[propName] = defaultProps[propName]);
+ } else props || (props = defaultProps || {});
+ return {
+ $$typeof: REACT_ELEMENT_TYPE,
+ type: type,
+ key: void 0 === key ? null : "" + key,
+ ref: null,
+ props: props,
+ _owner: null
+ };
+}
+
+module.exports = _createRawReactElement, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/maybeArrayLike.js b/node_modules/@babel/runtime/helpers/maybeArrayLike.js
new file mode 100644
index 000000000..212d68c73
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/maybeArrayLike.js
@@ -0,0 +1,12 @@
+var arrayLikeToArray = require("./arrayLikeToArray.js");
+
+function _maybeArrayLike(next, arr, i) {
+ if (arr && !Array.isArray(arr) && typeof arr.length === "number") {
+ var len = arr.length;
+ return arrayLikeToArray(arr, i !== void 0 && i < len ? i : len);
+ }
+
+ return next(arr, i);
+}
+
+module.exports = _maybeArrayLike, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/newArrowCheck.js b/node_modules/@babel/runtime/helpers/newArrowCheck.js
new file mode 100644
index 000000000..86a91f2bc
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/newArrowCheck.js
@@ -0,0 +1,7 @@
+function _newArrowCheck(innerThis, boundThis) {
+ if (innerThis !== boundThis) {
+ throw new TypeError("Cannot instantiate an arrow function");
+ }
+}
+
+module.exports = _newArrowCheck, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/nonIterableRest.js b/node_modules/@babel/runtime/helpers/nonIterableRest.js
new file mode 100644
index 000000000..e7911087d
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/nonIterableRest.js
@@ -0,0 +1,5 @@
+function _nonIterableRest() {
+ throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+
+module.exports = _nonIterableRest, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/nonIterableSpread.js b/node_modules/@babel/runtime/helpers/nonIterableSpread.js
new file mode 100644
index 000000000..64379ea2c
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/nonIterableSpread.js
@@ -0,0 +1,5 @@
+function _nonIterableSpread() {
+ throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+
+module.exports = _nonIterableSpread, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/objectDestructuringEmpty.js b/node_modules/@babel/runtime/helpers/objectDestructuringEmpty.js
new file mode 100644
index 000000000..cb0866e7d
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/objectDestructuringEmpty.js
@@ -0,0 +1,5 @@
+function _objectDestructuringEmpty(obj) {
+ if (obj == null) throw new TypeError("Cannot destructure undefined");
+}
+
+module.exports = _objectDestructuringEmpty, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/objectSpread.js b/node_modules/@babel/runtime/helpers/objectSpread.js
new file mode 100644
index 000000000..cfb430978
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/objectSpread.js
@@ -0,0 +1,22 @@
+var defineProperty = require("./defineProperty.js");
+
+function _objectSpread(target) {
+ for (var i = 1; i < arguments.length; i++) {
+ var source = arguments[i] != null ? Object(arguments[i]) : {};
+ var ownKeys = Object.keys(source);
+
+ if (typeof Object.getOwnPropertySymbols === 'function') {
+ ownKeys.push.apply(ownKeys, Object.getOwnPropertySymbols(source).filter(function (sym) {
+ return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+ }));
+ }
+
+ ownKeys.forEach(function (key) {
+ defineProperty(target, key, source[key]);
+ });
+ }
+
+ return target;
+}
+
+module.exports = _objectSpread, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/objectSpread2.js b/node_modules/@babel/runtime/helpers/objectSpread2.js
new file mode 100644
index 000000000..7e5db07d0
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/objectSpread2.js
@@ -0,0 +1,29 @@
+var defineProperty = require("./defineProperty.js");
+
+function ownKeys(object, enumerableOnly) {
+ var keys = Object.keys(object);
+
+ if (Object.getOwnPropertySymbols) {
+ var symbols = Object.getOwnPropertySymbols(object);
+ enumerableOnly && (symbols = symbols.filter(function (sym) {
+ return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+ })), keys.push.apply(keys, symbols);
+ }
+
+ return keys;
+}
+
+function _objectSpread2(target) {
+ for (var i = 1; i < arguments.length; i++) {
+ var source = null != arguments[i] ? arguments[i] : {};
+ i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {
+ defineProperty(target, key, source[key]);
+ }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {
+ Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+ });
+ }
+
+ return target;
+}
+
+module.exports = _objectSpread2, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/objectWithoutProperties.js b/node_modules/@babel/runtime/helpers/objectWithoutProperties.js
new file mode 100644
index 000000000..8cf3ab8d5
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/objectWithoutProperties.js
@@ -0,0 +1,22 @@
+var objectWithoutPropertiesLoose = require("./objectWithoutPropertiesLoose.js");
+
+function _objectWithoutProperties(source, excluded) {
+ if (source == null) return {};
+ var target = objectWithoutPropertiesLoose(source, excluded);
+ var key, i;
+
+ if (Object.getOwnPropertySymbols) {
+ var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+
+ for (i = 0; i < sourceSymbolKeys.length; i++) {
+ key = sourceSymbolKeys[i];
+ if (excluded.indexOf(key) >= 0) continue;
+ if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+ target[key] = source[key];
+ }
+ }
+
+ return target;
+}
+
+module.exports = _objectWithoutProperties, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/objectWithoutPropertiesLoose.js b/node_modules/@babel/runtime/helpers/objectWithoutPropertiesLoose.js
new file mode 100644
index 000000000..44d5771e3
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/objectWithoutPropertiesLoose.js
@@ -0,0 +1,16 @@
+function _objectWithoutPropertiesLoose(source, excluded) {
+ if (source == null) return {};
+ var target = {};
+ var sourceKeys = Object.keys(source);
+ var key, i;
+
+ for (i = 0; i < sourceKeys.length; i++) {
+ key = sourceKeys[i];
+ if (excluded.indexOf(key) >= 0) continue;
+ target[key] = source[key];
+ }
+
+ return target;
+}
+
+module.exports = _objectWithoutPropertiesLoose, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/possibleConstructorReturn.js b/node_modules/@babel/runtime/helpers/possibleConstructorReturn.js
new file mode 100644
index 000000000..e1997be41
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/possibleConstructorReturn.js
@@ -0,0 +1,15 @@
+var _typeof = require("./typeof.js")["default"];
+
+var assertThisInitialized = require("./assertThisInitialized.js");
+
+function _possibleConstructorReturn(self, call) {
+ if (call && (_typeof(call) === "object" || typeof call === "function")) {
+ return call;
+ } else if (call !== void 0) {
+ throw new TypeError("Derived constructors may only return object or undefined");
+ }
+
+ return assertThisInitialized(self);
+}
+
+module.exports = _possibleConstructorReturn, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/readOnlyError.js b/node_modules/@babel/runtime/helpers/readOnlyError.js
new file mode 100644
index 000000000..93cb90c6c
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/readOnlyError.js
@@ -0,0 +1,5 @@
+function _readOnlyError(name) {
+ throw new TypeError("\"" + name + "\" is read-only");
+}
+
+module.exports = _readOnlyError, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/set.js b/node_modules/@babel/runtime/helpers/set.js
new file mode 100644
index 000000000..6438def23
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/set.js
@@ -0,0 +1,54 @@
+var superPropBase = require("./superPropBase.js");
+
+var defineProperty = require("./defineProperty.js");
+
+function set(target, property, value, receiver) {
+ if (typeof Reflect !== "undefined" && Reflect.set) {
+ set = Reflect.set;
+ } else {
+ set = function set(target, property, value, receiver) {
+ var base = superPropBase(target, property);
+ var desc;
+
+ if (base) {
+ desc = Object.getOwnPropertyDescriptor(base, property);
+
+ if (desc.set) {
+ desc.set.call(receiver, value);
+ return true;
+ } else if (!desc.writable) {
+ return false;
+ }
+ }
+
+ desc = Object.getOwnPropertyDescriptor(receiver, property);
+
+ if (desc) {
+ if (!desc.writable) {
+ return false;
+ }
+
+ desc.value = value;
+ Object.defineProperty(receiver, property, desc);
+ } else {
+ defineProperty(receiver, property, value);
+ }
+
+ return true;
+ };
+ }
+
+ return set(target, property, value, receiver);
+}
+
+function _set(target, property, value, receiver, isStrict) {
+ var s = set(target, property, value, receiver || target);
+
+ if (!s && isStrict) {
+ throw new Error('failed to set property');
+ }
+
+ return value;
+}
+
+module.exports = _set, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/setPrototypeOf.js b/node_modules/@babel/runtime/helpers/setPrototypeOf.js
new file mode 100644
index 000000000..7efecade9
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/setPrototypeOf.js
@@ -0,0 +1,9 @@
+function _setPrototypeOf(o, p) {
+ module.exports = _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+ o.__proto__ = p;
+ return o;
+ }, module.exports.__esModule = true, module.exports["default"] = module.exports;
+ return _setPrototypeOf(o, p);
+}
+
+module.exports = _setPrototypeOf, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/skipFirstGeneratorNext.js b/node_modules/@babel/runtime/helpers/skipFirstGeneratorNext.js
new file mode 100644
index 000000000..88908962d
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/skipFirstGeneratorNext.js
@@ -0,0 +1,9 @@
+function _skipFirstGeneratorNext(fn) {
+ return function () {
+ var it = fn.apply(this, arguments);
+ it.next();
+ return it;
+ };
+}
+
+module.exports = _skipFirstGeneratorNext, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/slicedToArray.js b/node_modules/@babel/runtime/helpers/slicedToArray.js
new file mode 100644
index 000000000..bce5fc0be
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/slicedToArray.js
@@ -0,0 +1,13 @@
+var arrayWithHoles = require("./arrayWithHoles.js");
+
+var iterableToArrayLimit = require("./iterableToArrayLimit.js");
+
+var unsupportedIterableToArray = require("./unsupportedIterableToArray.js");
+
+var nonIterableRest = require("./nonIterableRest.js");
+
+function _slicedToArray(arr, i) {
+ return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();
+}
+
+module.exports = _slicedToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/slicedToArrayLoose.js b/node_modules/@babel/runtime/helpers/slicedToArrayLoose.js
new file mode 100644
index 000000000..cc9ace2fe
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/slicedToArrayLoose.js
@@ -0,0 +1,13 @@
+var arrayWithHoles = require("./arrayWithHoles.js");
+
+var iterableToArrayLimitLoose = require("./iterableToArrayLimitLoose.js");
+
+var unsupportedIterableToArray = require("./unsupportedIterableToArray.js");
+
+var nonIterableRest = require("./nonIterableRest.js");
+
+function _slicedToArrayLoose(arr, i) {
+ return arrayWithHoles(arr) || iterableToArrayLimitLoose(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();
+}
+
+module.exports = _slicedToArrayLoose, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/superPropBase.js b/node_modules/@babel/runtime/helpers/superPropBase.js
new file mode 100644
index 000000000..dd47fff77
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/superPropBase.js
@@ -0,0 +1,12 @@
+var getPrototypeOf = require("./getPrototypeOf.js");
+
+function _superPropBase(object, property) {
+ while (!Object.prototype.hasOwnProperty.call(object, property)) {
+ object = getPrototypeOf(object);
+ if (object === null) break;
+ }
+
+ return object;
+}
+
+module.exports = _superPropBase, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/taggedTemplateLiteral.js b/node_modules/@babel/runtime/helpers/taggedTemplateLiteral.js
new file mode 100644
index 000000000..6d9738ca5
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/taggedTemplateLiteral.js
@@ -0,0 +1,13 @@
+function _taggedTemplateLiteral(strings, raw) {
+ if (!raw) {
+ raw = strings.slice(0);
+ }
+
+ return Object.freeze(Object.defineProperties(strings, {
+ raw: {
+ value: Object.freeze(raw)
+ }
+ }));
+}
+
+module.exports = _taggedTemplateLiteral, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/taggedTemplateLiteralLoose.js b/node_modules/@babel/runtime/helpers/taggedTemplateLiteralLoose.js
new file mode 100644
index 000000000..4f151ca7c
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/taggedTemplateLiteralLoose.js
@@ -0,0 +1,10 @@
+function _taggedTemplateLiteralLoose(strings, raw) {
+ if (!raw) {
+ raw = strings.slice(0);
+ }
+
+ strings.raw = raw;
+ return strings;
+}
+
+module.exports = _taggedTemplateLiteralLoose, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/tdz.js b/node_modules/@babel/runtime/helpers/tdz.js
new file mode 100644
index 000000000..91ec2b227
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/tdz.js
@@ -0,0 +1,5 @@
+function _tdzError(name) {
+ throw new ReferenceError(name + " is not defined - temporal dead zone");
+}
+
+module.exports = _tdzError, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/temporalRef.js b/node_modules/@babel/runtime/helpers/temporalRef.js
new file mode 100644
index 000000000..6afd9323c
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/temporalRef.js
@@ -0,0 +1,9 @@
+var temporalUndefined = require("./temporalUndefined.js");
+
+var tdz = require("./tdz.js");
+
+function _temporalRef(val, name) {
+ return val === temporalUndefined ? tdz(name) : val;
+}
+
+module.exports = _temporalRef, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/temporalUndefined.js b/node_modules/@babel/runtime/helpers/temporalUndefined.js
new file mode 100644
index 000000000..7aca810f8
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/temporalUndefined.js
@@ -0,0 +1,3 @@
+function _temporalUndefined() {}
+
+module.exports = _temporalUndefined, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/toArray.js b/node_modules/@babel/runtime/helpers/toArray.js
new file mode 100644
index 000000000..d0af0e932
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/toArray.js
@@ -0,0 +1,13 @@
+var arrayWithHoles = require("./arrayWithHoles.js");
+
+var iterableToArray = require("./iterableToArray.js");
+
+var unsupportedIterableToArray = require("./unsupportedIterableToArray.js");
+
+var nonIterableRest = require("./nonIterableRest.js");
+
+function _toArray(arr) {
+ return arrayWithHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableRest();
+}
+
+module.exports = _toArray, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/toConsumableArray.js b/node_modules/@babel/runtime/helpers/toConsumableArray.js
new file mode 100644
index 000000000..9c69072cb
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/toConsumableArray.js
@@ -0,0 +1,13 @@
+var arrayWithoutHoles = require("./arrayWithoutHoles.js");
+
+var iterableToArray = require("./iterableToArray.js");
+
+var unsupportedIterableToArray = require("./unsupportedIterableToArray.js");
+
+var nonIterableSpread = require("./nonIterableSpread.js");
+
+function _toConsumableArray(arr) {
+ return arrayWithoutHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableSpread();
+}
+
+module.exports = _toConsumableArray, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/toPrimitive.js b/node_modules/@babel/runtime/helpers/toPrimitive.js
new file mode 100644
index 000000000..dc4da81a4
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/toPrimitive.js
@@ -0,0 +1,16 @@
+var _typeof = require("./typeof.js")["default"];
+
+function _toPrimitive(input, hint) {
+ if (_typeof(input) !== "object" || input === null) return input;
+ var prim = input[Symbol.toPrimitive];
+
+ if (prim !== undefined) {
+ var res = prim.call(input, hint || "default");
+ if (_typeof(res) !== "object") return res;
+ throw new TypeError("@@toPrimitive must return a primitive value.");
+ }
+
+ return (hint === "string" ? String : Number)(input);
+}
+
+module.exports = _toPrimitive, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/toPropertyKey.js b/node_modules/@babel/runtime/helpers/toPropertyKey.js
new file mode 100644
index 000000000..61367cf3a
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/toPropertyKey.js
@@ -0,0 +1,10 @@
+var _typeof = require("./typeof.js")["default"];
+
+var toPrimitive = require("./toPrimitive.js");
+
+function _toPropertyKey(arg) {
+ var key = toPrimitive(arg, "string");
+ return _typeof(key) === "symbol" ? key : String(key);
+}
+
+module.exports = _toPropertyKey, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/typeof.js b/node_modules/@babel/runtime/helpers/typeof.js
new file mode 100644
index 000000000..6c7860ff7
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/typeof.js
@@ -0,0 +1,11 @@
+function _typeof(obj) {
+ "@babel/helpers - typeof";
+
+ return (module.exports = _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
+ return typeof obj;
+ } : function (obj) {
+ return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+ }, module.exports.__esModule = true, module.exports["default"] = module.exports), _typeof(obj);
+}
+
+module.exports = _typeof, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js b/node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js
new file mode 100644
index 000000000..bfe65e403
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js
@@ -0,0 +1,12 @@
+var arrayLikeToArray = require("./arrayLikeToArray.js");
+
+function _unsupportedIterableToArray(o, minLen) {
+ if (!o) return;
+ if (typeof o === "string") return arrayLikeToArray(o, minLen);
+ var n = Object.prototype.toString.call(o).slice(8, -1);
+ if (n === "Object" && o.constructor) n = o.constructor.name;
+ if (n === "Map" || n === "Set") return Array.from(o);
+ if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return arrayLikeToArray(o, minLen);
+}
+
+module.exports = _unsupportedIterableToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/wrapAsyncGenerator.js b/node_modules/@babel/runtime/helpers/wrapAsyncGenerator.js
new file mode 100644
index 000000000..1fb4fd76e
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/wrapAsyncGenerator.js
@@ -0,0 +1,9 @@
+var AsyncGenerator = require("./AsyncGenerator.js");
+
+function _wrapAsyncGenerator(fn) {
+ return function () {
+ return new AsyncGenerator(fn.apply(this, arguments));
+ };
+}
+
+module.exports = _wrapAsyncGenerator, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/wrapNativeSuper.js b/node_modules/@babel/runtime/helpers/wrapNativeSuper.js
new file mode 100644
index 000000000..516220bff
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/wrapNativeSuper.js
@@ -0,0 +1,42 @@
+var getPrototypeOf = require("./getPrototypeOf.js");
+
+var setPrototypeOf = require("./setPrototypeOf.js");
+
+var isNativeFunction = require("./isNativeFunction.js");
+
+var construct = require("./construct.js");
+
+function _wrapNativeSuper(Class) {
+ var _cache = typeof Map === "function" ? new Map() : undefined;
+
+ module.exports = _wrapNativeSuper = function _wrapNativeSuper(Class) {
+ if (Class === null || !isNativeFunction(Class)) return Class;
+
+ if (typeof Class !== "function") {
+ throw new TypeError("Super expression must either be null or a function");
+ }
+
+ if (typeof _cache !== "undefined") {
+ if (_cache.has(Class)) return _cache.get(Class);
+
+ _cache.set(Class, Wrapper);
+ }
+
+ function Wrapper() {
+ return construct(Class, arguments, getPrototypeOf(this).constructor);
+ }
+
+ Wrapper.prototype = Object.create(Class.prototype, {
+ constructor: {
+ value: Wrapper,
+ enumerable: false,
+ writable: true,
+ configurable: true
+ }
+ });
+ return setPrototypeOf(Wrapper, Class);
+ }, module.exports.__esModule = true, module.exports["default"] = module.exports;
+ return _wrapNativeSuper(Class);
+}
+
+module.exports = _wrapNativeSuper, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/wrapRegExp.js b/node_modules/@babel/runtime/helpers/wrapRegExp.js
new file mode 100644
index 000000000..5b8342bd3
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/wrapRegExp.js
@@ -0,0 +1,55 @@
+var _typeof = require("./typeof.js")["default"];
+
+var setPrototypeOf = require("./setPrototypeOf.js");
+
+var inherits = require("./inherits.js");
+
+function _wrapRegExp() {
+ module.exports = _wrapRegExp = function _wrapRegExp(re, groups) {
+ return new BabelRegExp(re, void 0, groups);
+ }, module.exports.__esModule = true, module.exports["default"] = module.exports;
+
+ var _super = RegExp.prototype,
+ _groups = new WeakMap();
+
+ function BabelRegExp(re, flags, groups) {
+ var _this = new RegExp(re, flags);
+
+ return _groups.set(_this, groups || _groups.get(re)), setPrototypeOf(_this, BabelRegExp.prototype);
+ }
+
+ function buildGroups(result, re) {
+ var g = _groups.get(re);
+
+ return Object.keys(g).reduce(function (groups, name) {
+ return groups[name] = result[g[name]], groups;
+ }, Object.create(null));
+ }
+
+ return inherits(BabelRegExp, RegExp), BabelRegExp.prototype.exec = function (str) {
+ var result = _super.exec.call(this, str);
+
+ return result && (result.groups = buildGroups(result, this)), result;
+ }, BabelRegExp.prototype[Symbol.replace] = function (str, substitution) {
+ if ("string" == typeof substitution) {
+ var groups = _groups.get(this);
+
+ return _super[Symbol.replace].call(this, str, substitution.replace(/\$<([^>]+)>/g, function (_, name) {
+ return "$" + groups[name];
+ }));
+ }
+
+ if ("function" == typeof substitution) {
+ var _this = this;
+
+ return _super[Symbol.replace].call(this, str, function () {
+ var args = arguments;
+ return "object" != _typeof(args[args.length - 1]) && (args = [].slice.call(args)).push(buildGroups(args, _this)), substitution.apply(this, args);
+ });
+ }
+
+ return _super[Symbol.replace].call(this, str, substitution);
+ }, _wrapRegExp.apply(this, arguments);
+}
+
+module.exports = _wrapRegExp, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/writeOnlyError.js b/node_modules/@babel/runtime/helpers/writeOnlyError.js
new file mode 100644
index 000000000..132948733
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/writeOnlyError.js
@@ -0,0 +1,5 @@
+function _writeOnlyError(name) {
+ throw new TypeError("\"" + name + "\" is write-only");
+}
+
+module.exports = _writeOnlyError, module.exports.__esModule = true, module.exports["default"] = module.exports;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/package.json b/node_modules/@babel/runtime/package.json
new file mode 100644
index 000000000..3732ec93b
--- /dev/null
+++ b/node_modules/@babel/runtime/package.json
@@ -0,0 +1,866 @@
+{
+ "name": "@babel/runtime",
+ "version": "7.17.2",
+ "description": "babel's modular runtime helpers",
+ "license": "MIT",
+ "publishConfig": {
+ "access": "public"
+ },
+ "repository": {
+ "type": "git",
+ "url": "https://github.com/babel/babel.git",
+ "directory": "packages/babel-runtime"
+ },
+ "homepage": "https://babel.dev/docs/en/next/babel-runtime",
+ "author": "The Babel Team (https://babel.dev/team)",
+ "dependencies": {
+ "regenerator-runtime": "^0.13.4"
+ },
+ "exports": {
+ "./helpers/applyDecs": [
+ {
+ "node": "./helpers/applyDecs.js",
+ "import": "./helpers/esm/applyDecs.js",
+ "default": "./helpers/applyDecs.js"
+ },
+ "./helpers/applyDecs.js"
+ ],
+ "./helpers/esm/applyDecs": "./helpers/esm/applyDecs.js",
+ "./helpers/asyncIterator": [
+ {
+ "node": "./helpers/asyncIterator.js",
+ "import": "./helpers/esm/asyncIterator.js",
+ "default": "./helpers/asyncIterator.js"
+ },
+ "./helpers/asyncIterator.js"
+ ],
+ "./helpers/esm/asyncIterator": "./helpers/esm/asyncIterator.js",
+ "./helpers/jsx": [
+ {
+ "node": "./helpers/jsx.js",
+ "import": "./helpers/esm/jsx.js",
+ "default": "./helpers/jsx.js"
+ },
+ "./helpers/jsx.js"
+ ],
+ "./helpers/esm/jsx": "./helpers/esm/jsx.js",
+ "./helpers/objectSpread2": [
+ {
+ "node": "./helpers/objectSpread2.js",
+ "import": "./helpers/esm/objectSpread2.js",
+ "default": "./helpers/objectSpread2.js"
+ },
+ "./helpers/objectSpread2.js"
+ ],
+ "./helpers/esm/objectSpread2": "./helpers/esm/objectSpread2.js",
+ "./helpers/typeof": [
+ {
+ "node": "./helpers/typeof.js",
+ "import": "./helpers/esm/typeof.js",
+ "default": "./helpers/typeof.js"
+ },
+ "./helpers/typeof.js"
+ ],
+ "./helpers/esm/typeof": "./helpers/esm/typeof.js",
+ "./helpers/wrapRegExp": [
+ {
+ "node": "./helpers/wrapRegExp.js",
+ "import": "./helpers/esm/wrapRegExp.js",
+ "default": "./helpers/wrapRegExp.js"
+ },
+ "./helpers/wrapRegExp.js"
+ ],
+ "./helpers/esm/wrapRegExp": "./helpers/esm/wrapRegExp.js",
+ "./helpers/AwaitValue": [
+ {
+ "node": "./helpers/AwaitValue.js",
+ "import": "./helpers/esm/AwaitValue.js",
+ "default": "./helpers/AwaitValue.js"
+ },
+ "./helpers/AwaitValue.js"
+ ],
+ "./helpers/esm/AwaitValue": "./helpers/esm/AwaitValue.js",
+ "./helpers/AsyncGenerator": [
+ {
+ "node": "./helpers/AsyncGenerator.js",
+ "import": "./helpers/esm/AsyncGenerator.js",
+ "default": "./helpers/AsyncGenerator.js"
+ },
+ "./helpers/AsyncGenerator.js"
+ ],
+ "./helpers/esm/AsyncGenerator": "./helpers/esm/AsyncGenerator.js",
+ "./helpers/wrapAsyncGenerator": [
+ {
+ "node": "./helpers/wrapAsyncGenerator.js",
+ "import": "./helpers/esm/wrapAsyncGenerator.js",
+ "default": "./helpers/wrapAsyncGenerator.js"
+ },
+ "./helpers/wrapAsyncGenerator.js"
+ ],
+ "./helpers/esm/wrapAsyncGenerator": "./helpers/esm/wrapAsyncGenerator.js",
+ "./helpers/awaitAsyncGenerator": [
+ {
+ "node": "./helpers/awaitAsyncGenerator.js",
+ "import": "./helpers/esm/awaitAsyncGenerator.js",
+ "default": "./helpers/awaitAsyncGenerator.js"
+ },
+ "./helpers/awaitAsyncGenerator.js"
+ ],
+ "./helpers/esm/awaitAsyncGenerator": "./helpers/esm/awaitAsyncGenerator.js",
+ "./helpers/asyncGeneratorDelegate": [
+ {
+ "node": "./helpers/asyncGeneratorDelegate.js",
+ "import": "./helpers/esm/asyncGeneratorDelegate.js",
+ "default": "./helpers/asyncGeneratorDelegate.js"
+ },
+ "./helpers/asyncGeneratorDelegate.js"
+ ],
+ "./helpers/esm/asyncGeneratorDelegate": "./helpers/esm/asyncGeneratorDelegate.js",
+ "./helpers/asyncToGenerator": [
+ {
+ "node": "./helpers/asyncToGenerator.js",
+ "import": "./helpers/esm/asyncToGenerator.js",
+ "default": "./helpers/asyncToGenerator.js"
+ },
+ "./helpers/asyncToGenerator.js"
+ ],
+ "./helpers/esm/asyncToGenerator": "./helpers/esm/asyncToGenerator.js",
+ "./helpers/classCallCheck": [
+ {
+ "node": "./helpers/classCallCheck.js",
+ "import": "./helpers/esm/classCallCheck.js",
+ "default": "./helpers/classCallCheck.js"
+ },
+ "./helpers/classCallCheck.js"
+ ],
+ "./helpers/esm/classCallCheck": "./helpers/esm/classCallCheck.js",
+ "./helpers/createClass": [
+ {
+ "node": "./helpers/createClass.js",
+ "import": "./helpers/esm/createClass.js",
+ "default": "./helpers/createClass.js"
+ },
+ "./helpers/createClass.js"
+ ],
+ "./helpers/esm/createClass": "./helpers/esm/createClass.js",
+ "./helpers/defineEnumerableProperties": [
+ {
+ "node": "./helpers/defineEnumerableProperties.js",
+ "import": "./helpers/esm/defineEnumerableProperties.js",
+ "default": "./helpers/defineEnumerableProperties.js"
+ },
+ "./helpers/defineEnumerableProperties.js"
+ ],
+ "./helpers/esm/defineEnumerableProperties": "./helpers/esm/defineEnumerableProperties.js",
+ "./helpers/defaults": [
+ {
+ "node": "./helpers/defaults.js",
+ "import": "./helpers/esm/defaults.js",
+ "default": "./helpers/defaults.js"
+ },
+ "./helpers/defaults.js"
+ ],
+ "./helpers/esm/defaults": "./helpers/esm/defaults.js",
+ "./helpers/defineProperty": [
+ {
+ "node": "./helpers/defineProperty.js",
+ "import": "./helpers/esm/defineProperty.js",
+ "default": "./helpers/defineProperty.js"
+ },
+ "./helpers/defineProperty.js"
+ ],
+ "./helpers/esm/defineProperty": "./helpers/esm/defineProperty.js",
+ "./helpers/extends": [
+ {
+ "node": "./helpers/extends.js",
+ "import": "./helpers/esm/extends.js",
+ "default": "./helpers/extends.js"
+ },
+ "./helpers/extends.js"
+ ],
+ "./helpers/esm/extends": "./helpers/esm/extends.js",
+ "./helpers/objectSpread": [
+ {
+ "node": "./helpers/objectSpread.js",
+ "import": "./helpers/esm/objectSpread.js",
+ "default": "./helpers/objectSpread.js"
+ },
+ "./helpers/objectSpread.js"
+ ],
+ "./helpers/esm/objectSpread": "./helpers/esm/objectSpread.js",
+ "./helpers/inherits": [
+ {
+ "node": "./helpers/inherits.js",
+ "import": "./helpers/esm/inherits.js",
+ "default": "./helpers/inherits.js"
+ },
+ "./helpers/inherits.js"
+ ],
+ "./helpers/esm/inherits": "./helpers/esm/inherits.js",
+ "./helpers/inheritsLoose": [
+ {
+ "node": "./helpers/inheritsLoose.js",
+ "import": "./helpers/esm/inheritsLoose.js",
+ "default": "./helpers/inheritsLoose.js"
+ },
+ "./helpers/inheritsLoose.js"
+ ],
+ "./helpers/esm/inheritsLoose": "./helpers/esm/inheritsLoose.js",
+ "./helpers/getPrototypeOf": [
+ {
+ "node": "./helpers/getPrototypeOf.js",
+ "import": "./helpers/esm/getPrototypeOf.js",
+ "default": "./helpers/getPrototypeOf.js"
+ },
+ "./helpers/getPrototypeOf.js"
+ ],
+ "./helpers/esm/getPrototypeOf": "./helpers/esm/getPrototypeOf.js",
+ "./helpers/setPrototypeOf": [
+ {
+ "node": "./helpers/setPrototypeOf.js",
+ "import": "./helpers/esm/setPrototypeOf.js",
+ "default": "./helpers/setPrototypeOf.js"
+ },
+ "./helpers/setPrototypeOf.js"
+ ],
+ "./helpers/esm/setPrototypeOf": "./helpers/esm/setPrototypeOf.js",
+ "./helpers/isNativeReflectConstruct": [
+ {
+ "node": "./helpers/isNativeReflectConstruct.js",
+ "import": "./helpers/esm/isNativeReflectConstruct.js",
+ "default": "./helpers/isNativeReflectConstruct.js"
+ },
+ "./helpers/isNativeReflectConstruct.js"
+ ],
+ "./helpers/esm/isNativeReflectConstruct": "./helpers/esm/isNativeReflectConstruct.js",
+ "./helpers/construct": [
+ {
+ "node": "./helpers/construct.js",
+ "import": "./helpers/esm/construct.js",
+ "default": "./helpers/construct.js"
+ },
+ "./helpers/construct.js"
+ ],
+ "./helpers/esm/construct": "./helpers/esm/construct.js",
+ "./helpers/isNativeFunction": [
+ {
+ "node": "./helpers/isNativeFunction.js",
+ "import": "./helpers/esm/isNativeFunction.js",
+ "default": "./helpers/isNativeFunction.js"
+ },
+ "./helpers/isNativeFunction.js"
+ ],
+ "./helpers/esm/isNativeFunction": "./helpers/esm/isNativeFunction.js",
+ "./helpers/wrapNativeSuper": [
+ {
+ "node": "./helpers/wrapNativeSuper.js",
+ "import": "./helpers/esm/wrapNativeSuper.js",
+ "default": "./helpers/wrapNativeSuper.js"
+ },
+ "./helpers/wrapNativeSuper.js"
+ ],
+ "./helpers/esm/wrapNativeSuper": "./helpers/esm/wrapNativeSuper.js",
+ "./helpers/instanceof": [
+ {
+ "node": "./helpers/instanceof.js",
+ "import": "./helpers/esm/instanceof.js",
+ "default": "./helpers/instanceof.js"
+ },
+ "./helpers/instanceof.js"
+ ],
+ "./helpers/esm/instanceof": "./helpers/esm/instanceof.js",
+ "./helpers/interopRequireDefault": [
+ {
+ "node": "./helpers/interopRequireDefault.js",
+ "import": "./helpers/esm/interopRequireDefault.js",
+ "default": "./helpers/interopRequireDefault.js"
+ },
+ "./helpers/interopRequireDefault.js"
+ ],
+ "./helpers/esm/interopRequireDefault": "./helpers/esm/interopRequireDefault.js",
+ "./helpers/interopRequireWildcard": [
+ {
+ "node": "./helpers/interopRequireWildcard.js",
+ "import": "./helpers/esm/interopRequireWildcard.js",
+ "default": "./helpers/interopRequireWildcard.js"
+ },
+ "./helpers/interopRequireWildcard.js"
+ ],
+ "./helpers/esm/interopRequireWildcard": "./helpers/esm/interopRequireWildcard.js",
+ "./helpers/newArrowCheck": [
+ {
+ "node": "./helpers/newArrowCheck.js",
+ "import": "./helpers/esm/newArrowCheck.js",
+ "default": "./helpers/newArrowCheck.js"
+ },
+ "./helpers/newArrowCheck.js"
+ ],
+ "./helpers/esm/newArrowCheck": "./helpers/esm/newArrowCheck.js",
+ "./helpers/objectDestructuringEmpty": [
+ {
+ "node": "./helpers/objectDestructuringEmpty.js",
+ "import": "./helpers/esm/objectDestructuringEmpty.js",
+ "default": "./helpers/objectDestructuringEmpty.js"
+ },
+ "./helpers/objectDestructuringEmpty.js"
+ ],
+ "./helpers/esm/objectDestructuringEmpty": "./helpers/esm/objectDestructuringEmpty.js",
+ "./helpers/objectWithoutPropertiesLoose": [
+ {
+ "node": "./helpers/objectWithoutPropertiesLoose.js",
+ "import": "./helpers/esm/objectWithoutPropertiesLoose.js",
+ "default": "./helpers/objectWithoutPropertiesLoose.js"
+ },
+ "./helpers/objectWithoutPropertiesLoose.js"
+ ],
+ "./helpers/esm/objectWithoutPropertiesLoose": "./helpers/esm/objectWithoutPropertiesLoose.js",
+ "./helpers/objectWithoutProperties": [
+ {
+ "node": "./helpers/objectWithoutProperties.js",
+ "import": "./helpers/esm/objectWithoutProperties.js",
+ "default": "./helpers/objectWithoutProperties.js"
+ },
+ "./helpers/objectWithoutProperties.js"
+ ],
+ "./helpers/esm/objectWithoutProperties": "./helpers/esm/objectWithoutProperties.js",
+ "./helpers/assertThisInitialized": [
+ {
+ "node": "./helpers/assertThisInitialized.js",
+ "import": "./helpers/esm/assertThisInitialized.js",
+ "default": "./helpers/assertThisInitialized.js"
+ },
+ "./helpers/assertThisInitialized.js"
+ ],
+ "./helpers/esm/assertThisInitialized": "./helpers/esm/assertThisInitialized.js",
+ "./helpers/possibleConstructorReturn": [
+ {
+ "node": "./helpers/possibleConstructorReturn.js",
+ "import": "./helpers/esm/possibleConstructorReturn.js",
+ "default": "./helpers/possibleConstructorReturn.js"
+ },
+ "./helpers/possibleConstructorReturn.js"
+ ],
+ "./helpers/esm/possibleConstructorReturn": "./helpers/esm/possibleConstructorReturn.js",
+ "./helpers/createSuper": [
+ {
+ "node": "./helpers/createSuper.js",
+ "import": "./helpers/esm/createSuper.js",
+ "default": "./helpers/createSuper.js"
+ },
+ "./helpers/createSuper.js"
+ ],
+ "./helpers/esm/createSuper": "./helpers/esm/createSuper.js",
+ "./helpers/superPropBase": [
+ {
+ "node": "./helpers/superPropBase.js",
+ "import": "./helpers/esm/superPropBase.js",
+ "default": "./helpers/superPropBase.js"
+ },
+ "./helpers/superPropBase.js"
+ ],
+ "./helpers/esm/superPropBase": "./helpers/esm/superPropBase.js",
+ "./helpers/get": [
+ {
+ "node": "./helpers/get.js",
+ "import": "./helpers/esm/get.js",
+ "default": "./helpers/get.js"
+ },
+ "./helpers/get.js"
+ ],
+ "./helpers/esm/get": "./helpers/esm/get.js",
+ "./helpers/set": [
+ {
+ "node": "./helpers/set.js",
+ "import": "./helpers/esm/set.js",
+ "default": "./helpers/set.js"
+ },
+ "./helpers/set.js"
+ ],
+ "./helpers/esm/set": "./helpers/esm/set.js",
+ "./helpers/taggedTemplateLiteral": [
+ {
+ "node": "./helpers/taggedTemplateLiteral.js",
+ "import": "./helpers/esm/taggedTemplateLiteral.js",
+ "default": "./helpers/taggedTemplateLiteral.js"
+ },
+ "./helpers/taggedTemplateLiteral.js"
+ ],
+ "./helpers/esm/taggedTemplateLiteral": "./helpers/esm/taggedTemplateLiteral.js",
+ "./helpers/taggedTemplateLiteralLoose": [
+ {
+ "node": "./helpers/taggedTemplateLiteralLoose.js",
+ "import": "./helpers/esm/taggedTemplateLiteralLoose.js",
+ "default": "./helpers/taggedTemplateLiteralLoose.js"
+ },
+ "./helpers/taggedTemplateLiteralLoose.js"
+ ],
+ "./helpers/esm/taggedTemplateLiteralLoose": "./helpers/esm/taggedTemplateLiteralLoose.js",
+ "./helpers/readOnlyError": [
+ {
+ "node": "./helpers/readOnlyError.js",
+ "import": "./helpers/esm/readOnlyError.js",
+ "default": "./helpers/readOnlyError.js"
+ },
+ "./helpers/readOnlyError.js"
+ ],
+ "./helpers/esm/readOnlyError": "./helpers/esm/readOnlyError.js",
+ "./helpers/writeOnlyError": [
+ {
+ "node": "./helpers/writeOnlyError.js",
+ "import": "./helpers/esm/writeOnlyError.js",
+ "default": "./helpers/writeOnlyError.js"
+ },
+ "./helpers/writeOnlyError.js"
+ ],
+ "./helpers/esm/writeOnlyError": "./helpers/esm/writeOnlyError.js",
+ "./helpers/classNameTDZError": [
+ {
+ "node": "./helpers/classNameTDZError.js",
+ "import": "./helpers/esm/classNameTDZError.js",
+ "default": "./helpers/classNameTDZError.js"
+ },
+ "./helpers/classNameTDZError.js"
+ ],
+ "./helpers/esm/classNameTDZError": "./helpers/esm/classNameTDZError.js",
+ "./helpers/temporalUndefined": [
+ {
+ "node": "./helpers/temporalUndefined.js",
+ "import": "./helpers/esm/temporalUndefined.js",
+ "default": "./helpers/temporalUndefined.js"
+ },
+ "./helpers/temporalUndefined.js"
+ ],
+ "./helpers/esm/temporalUndefined": "./helpers/esm/temporalUndefined.js",
+ "./helpers/tdz": [
+ {
+ "node": "./helpers/tdz.js",
+ "import": "./helpers/esm/tdz.js",
+ "default": "./helpers/tdz.js"
+ },
+ "./helpers/tdz.js"
+ ],
+ "./helpers/esm/tdz": "./helpers/esm/tdz.js",
+ "./helpers/temporalRef": [
+ {
+ "node": "./helpers/temporalRef.js",
+ "import": "./helpers/esm/temporalRef.js",
+ "default": "./helpers/temporalRef.js"
+ },
+ "./helpers/temporalRef.js"
+ ],
+ "./helpers/esm/temporalRef": "./helpers/esm/temporalRef.js",
+ "./helpers/slicedToArray": [
+ {
+ "node": "./helpers/slicedToArray.js",
+ "import": "./helpers/esm/slicedToArray.js",
+ "default": "./helpers/slicedToArray.js"
+ },
+ "./helpers/slicedToArray.js"
+ ],
+ "./helpers/esm/slicedToArray": "./helpers/esm/slicedToArray.js",
+ "./helpers/slicedToArrayLoose": [
+ {
+ "node": "./helpers/slicedToArrayLoose.js",
+ "import": "./helpers/esm/slicedToArrayLoose.js",
+ "default": "./helpers/slicedToArrayLoose.js"
+ },
+ "./helpers/slicedToArrayLoose.js"
+ ],
+ "./helpers/esm/slicedToArrayLoose": "./helpers/esm/slicedToArrayLoose.js",
+ "./helpers/toArray": [
+ {
+ "node": "./helpers/toArray.js",
+ "import": "./helpers/esm/toArray.js",
+ "default": "./helpers/toArray.js"
+ },
+ "./helpers/toArray.js"
+ ],
+ "./helpers/esm/toArray": "./helpers/esm/toArray.js",
+ "./helpers/toConsumableArray": [
+ {
+ "node": "./helpers/toConsumableArray.js",
+ "import": "./helpers/esm/toConsumableArray.js",
+ "default": "./helpers/toConsumableArray.js"
+ },
+ "./helpers/toConsumableArray.js"
+ ],
+ "./helpers/esm/toConsumableArray": "./helpers/esm/toConsumableArray.js",
+ "./helpers/arrayWithoutHoles": [
+ {
+ "node": "./helpers/arrayWithoutHoles.js",
+ "import": "./helpers/esm/arrayWithoutHoles.js",
+ "default": "./helpers/arrayWithoutHoles.js"
+ },
+ "./helpers/arrayWithoutHoles.js"
+ ],
+ "./helpers/esm/arrayWithoutHoles": "./helpers/esm/arrayWithoutHoles.js",
+ "./helpers/arrayWithHoles": [
+ {
+ "node": "./helpers/arrayWithHoles.js",
+ "import": "./helpers/esm/arrayWithHoles.js",
+ "default": "./helpers/arrayWithHoles.js"
+ },
+ "./helpers/arrayWithHoles.js"
+ ],
+ "./helpers/esm/arrayWithHoles": "./helpers/esm/arrayWithHoles.js",
+ "./helpers/maybeArrayLike": [
+ {
+ "node": "./helpers/maybeArrayLike.js",
+ "import": "./helpers/esm/maybeArrayLike.js",
+ "default": "./helpers/maybeArrayLike.js"
+ },
+ "./helpers/maybeArrayLike.js"
+ ],
+ "./helpers/esm/maybeArrayLike": "./helpers/esm/maybeArrayLike.js",
+ "./helpers/iterableToArray": [
+ {
+ "node": "./helpers/iterableToArray.js",
+ "import": "./helpers/esm/iterableToArray.js",
+ "default": "./helpers/iterableToArray.js"
+ },
+ "./helpers/iterableToArray.js"
+ ],
+ "./helpers/esm/iterableToArray": "./helpers/esm/iterableToArray.js",
+ "./helpers/iterableToArrayLimit": [
+ {
+ "node": "./helpers/iterableToArrayLimit.js",
+ "import": "./helpers/esm/iterableToArrayLimit.js",
+ "default": "./helpers/iterableToArrayLimit.js"
+ },
+ "./helpers/iterableToArrayLimit.js"
+ ],
+ "./helpers/esm/iterableToArrayLimit": "./helpers/esm/iterableToArrayLimit.js",
+ "./helpers/iterableToArrayLimitLoose": [
+ {
+ "node": "./helpers/iterableToArrayLimitLoose.js",
+ "import": "./helpers/esm/iterableToArrayLimitLoose.js",
+ "default": "./helpers/iterableToArrayLimitLoose.js"
+ },
+ "./helpers/iterableToArrayLimitLoose.js"
+ ],
+ "./helpers/esm/iterableToArrayLimitLoose": "./helpers/esm/iterableToArrayLimitLoose.js",
+ "./helpers/unsupportedIterableToArray": [
+ {
+ "node": "./helpers/unsupportedIterableToArray.js",
+ "import": "./helpers/esm/unsupportedIterableToArray.js",
+ "default": "./helpers/unsupportedIterableToArray.js"
+ },
+ "./helpers/unsupportedIterableToArray.js"
+ ],
+ "./helpers/esm/unsupportedIterableToArray": "./helpers/esm/unsupportedIterableToArray.js",
+ "./helpers/arrayLikeToArray": [
+ {
+ "node": "./helpers/arrayLikeToArray.js",
+ "import": "./helpers/esm/arrayLikeToArray.js",
+ "default": "./helpers/arrayLikeToArray.js"
+ },
+ "./helpers/arrayLikeToArray.js"
+ ],
+ "./helpers/esm/arrayLikeToArray": "./helpers/esm/arrayLikeToArray.js",
+ "./helpers/nonIterableSpread": [
+ {
+ "node": "./helpers/nonIterableSpread.js",
+ "import": "./helpers/esm/nonIterableSpread.js",
+ "default": "./helpers/nonIterableSpread.js"
+ },
+ "./helpers/nonIterableSpread.js"
+ ],
+ "./helpers/esm/nonIterableSpread": "./helpers/esm/nonIterableSpread.js",
+ "./helpers/nonIterableRest": [
+ {
+ "node": "./helpers/nonIterableRest.js",
+ "import": "./helpers/esm/nonIterableRest.js",
+ "default": "./helpers/nonIterableRest.js"
+ },
+ "./helpers/nonIterableRest.js"
+ ],
+ "./helpers/esm/nonIterableRest": "./helpers/esm/nonIterableRest.js",
+ "./helpers/createForOfIteratorHelper": [
+ {
+ "node": "./helpers/createForOfIteratorHelper.js",
+ "import": "./helpers/esm/createForOfIteratorHelper.js",
+ "default": "./helpers/createForOfIteratorHelper.js"
+ },
+ "./helpers/createForOfIteratorHelper.js"
+ ],
+ "./helpers/esm/createForOfIteratorHelper": "./helpers/esm/createForOfIteratorHelper.js",
+ "./helpers/createForOfIteratorHelperLoose": [
+ {
+ "node": "./helpers/createForOfIteratorHelperLoose.js",
+ "import": "./helpers/esm/createForOfIteratorHelperLoose.js",
+ "default": "./helpers/createForOfIteratorHelperLoose.js"
+ },
+ "./helpers/createForOfIteratorHelperLoose.js"
+ ],
+ "./helpers/esm/createForOfIteratorHelperLoose": "./helpers/esm/createForOfIteratorHelperLoose.js",
+ "./helpers/skipFirstGeneratorNext": [
+ {
+ "node": "./helpers/skipFirstGeneratorNext.js",
+ "import": "./helpers/esm/skipFirstGeneratorNext.js",
+ "default": "./helpers/skipFirstGeneratorNext.js"
+ },
+ "./helpers/skipFirstGeneratorNext.js"
+ ],
+ "./helpers/esm/skipFirstGeneratorNext": "./helpers/esm/skipFirstGeneratorNext.js",
+ "./helpers/toPrimitive": [
+ {
+ "node": "./helpers/toPrimitive.js",
+ "import": "./helpers/esm/toPrimitive.js",
+ "default": "./helpers/toPrimitive.js"
+ },
+ "./helpers/toPrimitive.js"
+ ],
+ "./helpers/esm/toPrimitive": "./helpers/esm/toPrimitive.js",
+ "./helpers/toPropertyKey": [
+ {
+ "node": "./helpers/toPropertyKey.js",
+ "import": "./helpers/esm/toPropertyKey.js",
+ "default": "./helpers/toPropertyKey.js"
+ },
+ "./helpers/toPropertyKey.js"
+ ],
+ "./helpers/esm/toPropertyKey": "./helpers/esm/toPropertyKey.js",
+ "./helpers/initializerWarningHelper": [
+ {
+ "node": "./helpers/initializerWarningHelper.js",
+ "import": "./helpers/esm/initializerWarningHelper.js",
+ "default": "./helpers/initializerWarningHelper.js"
+ },
+ "./helpers/initializerWarningHelper.js"
+ ],
+ "./helpers/esm/initializerWarningHelper": "./helpers/esm/initializerWarningHelper.js",
+ "./helpers/initializerDefineProperty": [
+ {
+ "node": "./helpers/initializerDefineProperty.js",
+ "import": "./helpers/esm/initializerDefineProperty.js",
+ "default": "./helpers/initializerDefineProperty.js"
+ },
+ "./helpers/initializerDefineProperty.js"
+ ],
+ "./helpers/esm/initializerDefineProperty": "./helpers/esm/initializerDefineProperty.js",
+ "./helpers/applyDecoratedDescriptor": [
+ {
+ "node": "./helpers/applyDecoratedDescriptor.js",
+ "import": "./helpers/esm/applyDecoratedDescriptor.js",
+ "default": "./helpers/applyDecoratedDescriptor.js"
+ },
+ "./helpers/applyDecoratedDescriptor.js"
+ ],
+ "./helpers/esm/applyDecoratedDescriptor": "./helpers/esm/applyDecoratedDescriptor.js",
+ "./helpers/classPrivateFieldLooseKey": [
+ {
+ "node": "./helpers/classPrivateFieldLooseKey.js",
+ "import": "./helpers/esm/classPrivateFieldLooseKey.js",
+ "default": "./helpers/classPrivateFieldLooseKey.js"
+ },
+ "./helpers/classPrivateFieldLooseKey.js"
+ ],
+ "./helpers/esm/classPrivateFieldLooseKey": "./helpers/esm/classPrivateFieldLooseKey.js",
+ "./helpers/classPrivateFieldLooseBase": [
+ {
+ "node": "./helpers/classPrivateFieldLooseBase.js",
+ "import": "./helpers/esm/classPrivateFieldLooseBase.js",
+ "default": "./helpers/classPrivateFieldLooseBase.js"
+ },
+ "./helpers/classPrivateFieldLooseBase.js"
+ ],
+ "./helpers/esm/classPrivateFieldLooseBase": "./helpers/esm/classPrivateFieldLooseBase.js",
+ "./helpers/classPrivateFieldGet": [
+ {
+ "node": "./helpers/classPrivateFieldGet.js",
+ "import": "./helpers/esm/classPrivateFieldGet.js",
+ "default": "./helpers/classPrivateFieldGet.js"
+ },
+ "./helpers/classPrivateFieldGet.js"
+ ],
+ "./helpers/esm/classPrivateFieldGet": "./helpers/esm/classPrivateFieldGet.js",
+ "./helpers/classPrivateFieldSet": [
+ {
+ "node": "./helpers/classPrivateFieldSet.js",
+ "import": "./helpers/esm/classPrivateFieldSet.js",
+ "default": "./helpers/classPrivateFieldSet.js"
+ },
+ "./helpers/classPrivateFieldSet.js"
+ ],
+ "./helpers/esm/classPrivateFieldSet": "./helpers/esm/classPrivateFieldSet.js",
+ "./helpers/classPrivateFieldDestructureSet": [
+ {
+ "node": "./helpers/classPrivateFieldDestructureSet.js",
+ "import": "./helpers/esm/classPrivateFieldDestructureSet.js",
+ "default": "./helpers/classPrivateFieldDestructureSet.js"
+ },
+ "./helpers/classPrivateFieldDestructureSet.js"
+ ],
+ "./helpers/esm/classPrivateFieldDestructureSet": "./helpers/esm/classPrivateFieldDestructureSet.js",
+ "./helpers/classExtractFieldDescriptor": [
+ {
+ "node": "./helpers/classExtractFieldDescriptor.js",
+ "import": "./helpers/esm/classExtractFieldDescriptor.js",
+ "default": "./helpers/classExtractFieldDescriptor.js"
+ },
+ "./helpers/classExtractFieldDescriptor.js"
+ ],
+ "./helpers/esm/classExtractFieldDescriptor": "./helpers/esm/classExtractFieldDescriptor.js",
+ "./helpers/classStaticPrivateFieldSpecGet": [
+ {
+ "node": "./helpers/classStaticPrivateFieldSpecGet.js",
+ "import": "./helpers/esm/classStaticPrivateFieldSpecGet.js",
+ "default": "./helpers/classStaticPrivateFieldSpecGet.js"
+ },
+ "./helpers/classStaticPrivateFieldSpecGet.js"
+ ],
+ "./helpers/esm/classStaticPrivateFieldSpecGet": "./helpers/esm/classStaticPrivateFieldSpecGet.js",
+ "./helpers/classStaticPrivateFieldSpecSet": [
+ {
+ "node": "./helpers/classStaticPrivateFieldSpecSet.js",
+ "import": "./helpers/esm/classStaticPrivateFieldSpecSet.js",
+ "default": "./helpers/classStaticPrivateFieldSpecSet.js"
+ },
+ "./helpers/classStaticPrivateFieldSpecSet.js"
+ ],
+ "./helpers/esm/classStaticPrivateFieldSpecSet": "./helpers/esm/classStaticPrivateFieldSpecSet.js",
+ "./helpers/classStaticPrivateMethodGet": [
+ {
+ "node": "./helpers/classStaticPrivateMethodGet.js",
+ "import": "./helpers/esm/classStaticPrivateMethodGet.js",
+ "default": "./helpers/classStaticPrivateMethodGet.js"
+ },
+ "./helpers/classStaticPrivateMethodGet.js"
+ ],
+ "./helpers/esm/classStaticPrivateMethodGet": "./helpers/esm/classStaticPrivateMethodGet.js",
+ "./helpers/classStaticPrivateMethodSet": [
+ {
+ "node": "./helpers/classStaticPrivateMethodSet.js",
+ "import": "./helpers/esm/classStaticPrivateMethodSet.js",
+ "default": "./helpers/classStaticPrivateMethodSet.js"
+ },
+ "./helpers/classStaticPrivateMethodSet.js"
+ ],
+ "./helpers/esm/classStaticPrivateMethodSet": "./helpers/esm/classStaticPrivateMethodSet.js",
+ "./helpers/classApplyDescriptorGet": [
+ {
+ "node": "./helpers/classApplyDescriptorGet.js",
+ "import": "./helpers/esm/classApplyDescriptorGet.js",
+ "default": "./helpers/classApplyDescriptorGet.js"
+ },
+ "./helpers/classApplyDescriptorGet.js"
+ ],
+ "./helpers/esm/classApplyDescriptorGet": "./helpers/esm/classApplyDescriptorGet.js",
+ "./helpers/classApplyDescriptorSet": [
+ {
+ "node": "./helpers/classApplyDescriptorSet.js",
+ "import": "./helpers/esm/classApplyDescriptorSet.js",
+ "default": "./helpers/classApplyDescriptorSet.js"
+ },
+ "./helpers/classApplyDescriptorSet.js"
+ ],
+ "./helpers/esm/classApplyDescriptorSet": "./helpers/esm/classApplyDescriptorSet.js",
+ "./helpers/classApplyDescriptorDestructureSet": [
+ {
+ "node": "./helpers/classApplyDescriptorDestructureSet.js",
+ "import": "./helpers/esm/classApplyDescriptorDestructureSet.js",
+ "default": "./helpers/classApplyDescriptorDestructureSet.js"
+ },
+ "./helpers/classApplyDescriptorDestructureSet.js"
+ ],
+ "./helpers/esm/classApplyDescriptorDestructureSet": "./helpers/esm/classApplyDescriptorDestructureSet.js",
+ "./helpers/classStaticPrivateFieldDestructureSet": [
+ {
+ "node": "./helpers/classStaticPrivateFieldDestructureSet.js",
+ "import": "./helpers/esm/classStaticPrivateFieldDestructureSet.js",
+ "default": "./helpers/classStaticPrivateFieldDestructureSet.js"
+ },
+ "./helpers/classStaticPrivateFieldDestructureSet.js"
+ ],
+ "./helpers/esm/classStaticPrivateFieldDestructureSet": "./helpers/esm/classStaticPrivateFieldDestructureSet.js",
+ "./helpers/classCheckPrivateStaticAccess": [
+ {
+ "node": "./helpers/classCheckPrivateStaticAccess.js",
+ "import": "./helpers/esm/classCheckPrivateStaticAccess.js",
+ "default": "./helpers/classCheckPrivateStaticAccess.js"
+ },
+ "./helpers/classCheckPrivateStaticAccess.js"
+ ],
+ "./helpers/esm/classCheckPrivateStaticAccess": "./helpers/esm/classCheckPrivateStaticAccess.js",
+ "./helpers/classCheckPrivateStaticFieldDescriptor": [
+ {
+ "node": "./helpers/classCheckPrivateStaticFieldDescriptor.js",
+ "import": "./helpers/esm/classCheckPrivateStaticFieldDescriptor.js",
+ "default": "./helpers/classCheckPrivateStaticFieldDescriptor.js"
+ },
+ "./helpers/classCheckPrivateStaticFieldDescriptor.js"
+ ],
+ "./helpers/esm/classCheckPrivateStaticFieldDescriptor": "./helpers/esm/classCheckPrivateStaticFieldDescriptor.js",
+ "./helpers/decorate": [
+ {
+ "node": "./helpers/decorate.js",
+ "import": "./helpers/esm/decorate.js",
+ "default": "./helpers/decorate.js"
+ },
+ "./helpers/decorate.js"
+ ],
+ "./helpers/esm/decorate": "./helpers/esm/decorate.js",
+ "./helpers/classPrivateMethodGet": [
+ {
+ "node": "./helpers/classPrivateMethodGet.js",
+ "import": "./helpers/esm/classPrivateMethodGet.js",
+ "default": "./helpers/classPrivateMethodGet.js"
+ },
+ "./helpers/classPrivateMethodGet.js"
+ ],
+ "./helpers/esm/classPrivateMethodGet": "./helpers/esm/classPrivateMethodGet.js",
+ "./helpers/checkPrivateRedeclaration": [
+ {
+ "node": "./helpers/checkPrivateRedeclaration.js",
+ "import": "./helpers/esm/checkPrivateRedeclaration.js",
+ "default": "./helpers/checkPrivateRedeclaration.js"
+ },
+ "./helpers/checkPrivateRedeclaration.js"
+ ],
+ "./helpers/esm/checkPrivateRedeclaration": "./helpers/esm/checkPrivateRedeclaration.js",
+ "./helpers/classPrivateFieldInitSpec": [
+ {
+ "node": "./helpers/classPrivateFieldInitSpec.js",
+ "import": "./helpers/esm/classPrivateFieldInitSpec.js",
+ "default": "./helpers/classPrivateFieldInitSpec.js"
+ },
+ "./helpers/classPrivateFieldInitSpec.js"
+ ],
+ "./helpers/esm/classPrivateFieldInitSpec": "./helpers/esm/classPrivateFieldInitSpec.js",
+ "./helpers/classPrivateMethodInitSpec": [
+ {
+ "node": "./helpers/classPrivateMethodInitSpec.js",
+ "import": "./helpers/esm/classPrivateMethodInitSpec.js",
+ "default": "./helpers/classPrivateMethodInitSpec.js"
+ },
+ "./helpers/classPrivateMethodInitSpec.js"
+ ],
+ "./helpers/esm/classPrivateMethodInitSpec": "./helpers/esm/classPrivateMethodInitSpec.js",
+ "./helpers/classPrivateMethodSet": [
+ {
+ "node": "./helpers/classPrivateMethodSet.js",
+ "import": "./helpers/esm/classPrivateMethodSet.js",
+ "default": "./helpers/classPrivateMethodSet.js"
+ },
+ "./helpers/classPrivateMethodSet.js"
+ ],
+ "./helpers/esm/classPrivateMethodSet": "./helpers/esm/classPrivateMethodSet.js",
+ "./helpers/identity": [
+ {
+ "node": "./helpers/identity.js",
+ "import": "./helpers/esm/identity.js",
+ "default": "./helpers/identity.js"
+ },
+ "./helpers/identity.js"
+ ],
+ "./helpers/esm/identity": "./helpers/esm/identity.js",
+ "./package": "./package.json",
+ "./package.json": "./package.json",
+ "./regenerator": "./regenerator/index.js",
+ "./regenerator/*.js": "./regenerator/*.js",
+ "./regenerator/": "./regenerator/"
+ },
+ "engines": {
+ "node": ">=6.9.0"
+ }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/regenerator/index.js b/node_modules/@babel/runtime/regenerator/index.js
new file mode 100644
index 000000000..9fd4158a6
--- /dev/null
+++ b/node_modules/@babel/runtime/regenerator/index.js
@@ -0,0 +1 @@
+module.exports = require("regenerator-runtime");
diff --git a/node_modules/@babel/template/LICENSE b/node_modules/@babel/template/LICENSE
new file mode 100644
index 000000000..f31575ec7
--- /dev/null
+++ b/node_modules/@babel/template/LICENSE
@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/node_modules/@babel/template/README.md b/node_modules/@babel/template/README.md
new file mode 100644
index 000000000..759c65aa6
--- /dev/null
+++ b/node_modules/@babel/template/README.md
@@ -0,0 +1,19 @@
+# @babel/template
+
+> Generate an AST from a string template.
+
+See our website [@babel/template](https://babeljs.io/docs/en/babel-template) for more information or the [issues](https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20template%22+is%3Aopen) associated with this package.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save-dev @babel/template
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/template --dev
+```
diff --git a/node_modules/@babel/template/lib/builder.js b/node_modules/@babel/template/lib/builder.js
new file mode 100644
index 000000000..e65b27d77
--- /dev/null
+++ b/node_modules/@babel/template/lib/builder.js
@@ -0,0 +1,81 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = createTemplateBuilder;
+
+var _options = require("./options");
+
+var _string = require("./string");
+
+var _literal = require("./literal");
+
+const NO_PLACEHOLDER = (0, _options.validate)({
+ placeholderPattern: false
+});
+
+function createTemplateBuilder(formatter, defaultOpts) {
+ const templateFnCache = new WeakMap();
+ const templateAstCache = new WeakMap();
+ const cachedOpts = defaultOpts || (0, _options.validate)(null);
+ return Object.assign((tpl, ...args) => {
+ if (typeof tpl === "string") {
+ if (args.length > 1) throw new Error("Unexpected extra params.");
+ return extendedTrace((0, _string.default)(formatter, tpl, (0, _options.merge)(cachedOpts, (0, _options.validate)(args[0]))));
+ } else if (Array.isArray(tpl)) {
+ let builder = templateFnCache.get(tpl);
+
+ if (!builder) {
+ builder = (0, _literal.default)(formatter, tpl, cachedOpts);
+ templateFnCache.set(tpl, builder);
+ }
+
+ return extendedTrace(builder(args));
+ } else if (typeof tpl === "object" && tpl) {
+ if (args.length > 0) throw new Error("Unexpected extra params.");
+ return createTemplateBuilder(formatter, (0, _options.merge)(cachedOpts, (0, _options.validate)(tpl)));
+ }
+
+ throw new Error(`Unexpected template param ${typeof tpl}`);
+ }, {
+ ast: (tpl, ...args) => {
+ if (typeof tpl === "string") {
+ if (args.length > 1) throw new Error("Unexpected extra params.");
+ return (0, _string.default)(formatter, tpl, (0, _options.merge)((0, _options.merge)(cachedOpts, (0, _options.validate)(args[0])), NO_PLACEHOLDER))();
+ } else if (Array.isArray(tpl)) {
+ let builder = templateAstCache.get(tpl);
+
+ if (!builder) {
+ builder = (0, _literal.default)(formatter, tpl, (0, _options.merge)(cachedOpts, NO_PLACEHOLDER));
+ templateAstCache.set(tpl, builder);
+ }
+
+ return builder(args)();
+ }
+
+ throw new Error(`Unexpected template param ${typeof tpl}`);
+ }
+ });
+}
+
+function extendedTrace(fn) {
+ let rootStack = "";
+
+ try {
+ throw new Error();
+ } catch (error) {
+ if (error.stack) {
+ rootStack = error.stack.split("\n").slice(3).join("\n");
+ }
+ }
+
+ return arg => {
+ try {
+ return fn(arg);
+ } catch (err) {
+ err.stack += `\n =============\n${rootStack}`;
+ throw err;
+ }
+ };
+}
\ No newline at end of file
diff --git a/node_modules/@babel/template/lib/formatters.js b/node_modules/@babel/template/lib/formatters.js
new file mode 100644
index 000000000..ab9168b60
--- /dev/null
+++ b/node_modules/@babel/template/lib/formatters.js
@@ -0,0 +1,71 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.statements = exports.statement = exports.smart = exports.program = exports.expression = void 0;
+
+var _t = require("@babel/types");
+
+const {
+ assertExpressionStatement
+} = _t;
+
+function makeStatementFormatter(fn) {
+ return {
+ code: str => `/* @babel/template */;\n${str}`,
+ validate: () => {},
+ unwrap: ast => {
+ return fn(ast.program.body.slice(1));
+ }
+ };
+}
+
+const smart = makeStatementFormatter(body => {
+ if (body.length > 1) {
+ return body;
+ } else {
+ return body[0];
+ }
+});
+exports.smart = smart;
+const statements = makeStatementFormatter(body => body);
+exports.statements = statements;
+const statement = makeStatementFormatter(body => {
+ if (body.length === 0) {
+ throw new Error("Found nothing to return.");
+ }
+
+ if (body.length > 1) {
+ throw new Error("Found multiple statements but wanted one");
+ }
+
+ return body[0];
+});
+exports.statement = statement;
+const expression = {
+ code: str => `(\n${str}\n)`,
+ validate: ast => {
+ if (ast.program.body.length > 1) {
+ throw new Error("Found multiple statements but wanted one");
+ }
+
+ if (expression.unwrap(ast).start === 0) {
+ throw new Error("Parse result included parens.");
+ }
+ },
+ unwrap: ({
+ program
+ }) => {
+ const [stmt] = program.body;
+ assertExpressionStatement(stmt);
+ return stmt.expression;
+ }
+};
+exports.expression = expression;
+const program = {
+ code: str => str,
+ validate: () => {},
+ unwrap: ast => ast.program
+};
+exports.program = program;
\ No newline at end of file
diff --git a/node_modules/@babel/template/lib/index.js b/node_modules/@babel/template/lib/index.js
new file mode 100644
index 000000000..b75aacdcc
--- /dev/null
+++ b/node_modules/@babel/template/lib/index.js
@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.statements = exports.statement = exports.smart = exports.program = exports.expression = exports.default = void 0;
+
+var formatters = require("./formatters");
+
+var _builder = require("./builder");
+
+const smart = (0, _builder.default)(formatters.smart);
+exports.smart = smart;
+const statement = (0, _builder.default)(formatters.statement);
+exports.statement = statement;
+const statements = (0, _builder.default)(formatters.statements);
+exports.statements = statements;
+const expression = (0, _builder.default)(formatters.expression);
+exports.expression = expression;
+const program = (0, _builder.default)(formatters.program);
+exports.program = program;
+
+var _default = Object.assign(smart.bind(undefined), {
+ smart,
+ statement,
+ statements,
+ expression,
+ program,
+ ast: smart.ast
+});
+
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/template/lib/literal.js b/node_modules/@babel/template/lib/literal.js
new file mode 100644
index 000000000..fd194c6ab
--- /dev/null
+++ b/node_modules/@babel/template/lib/literal.js
@@ -0,0 +1,80 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = literalTemplate;
+
+var _options = require("./options");
+
+var _parse = require("./parse");
+
+var _populate = require("./populate");
+
+function literalTemplate(formatter, tpl, opts) {
+ const {
+ metadata,
+ names
+ } = buildLiteralData(formatter, tpl, opts);
+ return arg => {
+ const defaultReplacements = {};
+ arg.forEach((replacement, i) => {
+ defaultReplacements[names[i]] = replacement;
+ });
+ return arg => {
+ const replacements = (0, _options.normalizeReplacements)(arg);
+
+ if (replacements) {
+ Object.keys(replacements).forEach(key => {
+ if (Object.prototype.hasOwnProperty.call(defaultReplacements, key)) {
+ throw new Error("Unexpected replacement overlap.");
+ }
+ });
+ }
+
+ return formatter.unwrap((0, _populate.default)(metadata, replacements ? Object.assign(replacements, defaultReplacements) : defaultReplacements));
+ };
+ };
+}
+
+function buildLiteralData(formatter, tpl, opts) {
+ let names;
+ let nameSet;
+ let metadata;
+ let prefix = "";
+
+ do {
+ prefix += "$";
+ const result = buildTemplateCode(tpl, prefix);
+ names = result.names;
+ nameSet = new Set(names);
+ metadata = (0, _parse.default)(formatter, formatter.code(result.code), {
+ parser: opts.parser,
+ placeholderWhitelist: new Set(result.names.concat(opts.placeholderWhitelist ? Array.from(opts.placeholderWhitelist) : [])),
+ placeholderPattern: opts.placeholderPattern,
+ preserveComments: opts.preserveComments,
+ syntacticPlaceholders: opts.syntacticPlaceholders
+ });
+ } while (metadata.placeholders.some(placeholder => placeholder.isDuplicate && nameSet.has(placeholder.name)));
+
+ return {
+ metadata,
+ names
+ };
+}
+
+function buildTemplateCode(tpl, prefix) {
+ const names = [];
+ let code = tpl[0];
+
+ for (let i = 1; i < tpl.length; i++) {
+ const value = `${prefix}${i - 1}`;
+ names.push(value);
+ code += value + tpl[i];
+ }
+
+ return {
+ names,
+ code
+ };
+}
\ No newline at end of file
diff --git a/node_modules/@babel/template/lib/options.js b/node_modules/@babel/template/lib/options.js
new file mode 100644
index 000000000..95c31e74b
--- /dev/null
+++ b/node_modules/@babel/template/lib/options.js
@@ -0,0 +1,83 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.merge = merge;
+exports.normalizeReplacements = normalizeReplacements;
+exports.validate = validate;
+const _excluded = ["placeholderWhitelist", "placeholderPattern", "preserveComments", "syntacticPlaceholders"];
+
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+
+function merge(a, b) {
+ const {
+ placeholderWhitelist = a.placeholderWhitelist,
+ placeholderPattern = a.placeholderPattern,
+ preserveComments = a.preserveComments,
+ syntacticPlaceholders = a.syntacticPlaceholders
+ } = b;
+ return {
+ parser: Object.assign({}, a.parser, b.parser),
+ placeholderWhitelist,
+ placeholderPattern,
+ preserveComments,
+ syntacticPlaceholders
+ };
+}
+
+function validate(opts) {
+ if (opts != null && typeof opts !== "object") {
+ throw new Error("Unknown template options.");
+ }
+
+ const _ref = opts || {},
+ {
+ placeholderWhitelist,
+ placeholderPattern,
+ preserveComments,
+ syntacticPlaceholders
+ } = _ref,
+ parser = _objectWithoutPropertiesLoose(_ref, _excluded);
+
+ if (placeholderWhitelist != null && !(placeholderWhitelist instanceof Set)) {
+ throw new Error("'.placeholderWhitelist' must be a Set, null, or undefined");
+ }
+
+ if (placeholderPattern != null && !(placeholderPattern instanceof RegExp) && placeholderPattern !== false) {
+ throw new Error("'.placeholderPattern' must be a RegExp, false, null, or undefined");
+ }
+
+ if (preserveComments != null && typeof preserveComments !== "boolean") {
+ throw new Error("'.preserveComments' must be a boolean, null, or undefined");
+ }
+
+ if (syntacticPlaceholders != null && typeof syntacticPlaceholders !== "boolean") {
+ throw new Error("'.syntacticPlaceholders' must be a boolean, null, or undefined");
+ }
+
+ if (syntacticPlaceholders === true && (placeholderWhitelist != null || placeholderPattern != null)) {
+ throw new Error("'.placeholderWhitelist' and '.placeholderPattern' aren't compatible" + " with '.syntacticPlaceholders: true'");
+ }
+
+ return {
+ parser,
+ placeholderWhitelist: placeholderWhitelist || undefined,
+ placeholderPattern: placeholderPattern == null ? undefined : placeholderPattern,
+ preserveComments: preserveComments == null ? undefined : preserveComments,
+ syntacticPlaceholders: syntacticPlaceholders == null ? undefined : syntacticPlaceholders
+ };
+}
+
+function normalizeReplacements(replacements) {
+ if (Array.isArray(replacements)) {
+ return replacements.reduce((acc, replacement, i) => {
+ acc["$" + i] = replacement;
+ return acc;
+ }, {});
+ } else if (typeof replacements === "object" || replacements == null) {
+ return replacements || undefined;
+ }
+
+ throw new Error("Template replacements must be an array, object, null, or undefined");
+}
\ No newline at end of file
diff --git a/node_modules/@babel/template/lib/parse.js b/node_modules/@babel/template/lib/parse.js
new file mode 100644
index 000000000..0d42ed435
--- /dev/null
+++ b/node_modules/@babel/template/lib/parse.js
@@ -0,0 +1,188 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = parseAndBuildMetadata;
+
+var _t = require("@babel/types");
+
+var _parser = require("@babel/parser");
+
+var _codeFrame = require("@babel/code-frame");
+
+const {
+ isCallExpression,
+ isExpressionStatement,
+ isFunction,
+ isIdentifier,
+ isJSXIdentifier,
+ isNewExpression,
+ isPlaceholder,
+ isStatement,
+ isStringLiteral,
+ removePropertiesDeep,
+ traverse
+} = _t;
+const PATTERN = /^[_$A-Z0-9]+$/;
+
+function parseAndBuildMetadata(formatter, code, opts) {
+ const {
+ placeholderWhitelist,
+ placeholderPattern,
+ preserveComments,
+ syntacticPlaceholders
+ } = opts;
+ const ast = parseWithCodeFrame(code, opts.parser, syntacticPlaceholders);
+ removePropertiesDeep(ast, {
+ preserveComments
+ });
+ formatter.validate(ast);
+ const syntactic = {
+ placeholders: [],
+ placeholderNames: new Set()
+ };
+ const legacy = {
+ placeholders: [],
+ placeholderNames: new Set()
+ };
+ const isLegacyRef = {
+ value: undefined
+ };
+ traverse(ast, placeholderVisitorHandler, {
+ syntactic,
+ legacy,
+ isLegacyRef,
+ placeholderWhitelist,
+ placeholderPattern,
+ syntacticPlaceholders
+ });
+ return Object.assign({
+ ast
+ }, isLegacyRef.value ? legacy : syntactic);
+}
+
+function placeholderVisitorHandler(node, ancestors, state) {
+ var _state$placeholderWhi;
+
+ let name;
+
+ if (isPlaceholder(node)) {
+ if (state.syntacticPlaceholders === false) {
+ throw new Error("%%foo%%-style placeholders can't be used when " + "'.syntacticPlaceholders' is false.");
+ } else {
+ name = node.name.name;
+ state.isLegacyRef.value = false;
+ }
+ } else if (state.isLegacyRef.value === false || state.syntacticPlaceholders) {
+ return;
+ } else if (isIdentifier(node) || isJSXIdentifier(node)) {
+ name = node.name;
+ state.isLegacyRef.value = true;
+ } else if (isStringLiteral(node)) {
+ name = node.value;
+ state.isLegacyRef.value = true;
+ } else {
+ return;
+ }
+
+ if (!state.isLegacyRef.value && (state.placeholderPattern != null || state.placeholderWhitelist != null)) {
+ throw new Error("'.placeholderWhitelist' and '.placeholderPattern' aren't compatible" + " with '.syntacticPlaceholders: true'");
+ }
+
+ if (state.isLegacyRef.value && (state.placeholderPattern === false || !(state.placeholderPattern || PATTERN).test(name)) && !((_state$placeholderWhi = state.placeholderWhitelist) != null && _state$placeholderWhi.has(name))) {
+ return;
+ }
+
+ ancestors = ancestors.slice();
+ const {
+ node: parent,
+ key
+ } = ancestors[ancestors.length - 1];
+ let type;
+
+ if (isStringLiteral(node) || isPlaceholder(node, {
+ expectedNode: "StringLiteral"
+ })) {
+ type = "string";
+ } else if (isNewExpression(parent) && key === "arguments" || isCallExpression(parent) && key === "arguments" || isFunction(parent) && key === "params") {
+ type = "param";
+ } else if (isExpressionStatement(parent) && !isPlaceholder(node)) {
+ type = "statement";
+ ancestors = ancestors.slice(0, -1);
+ } else if (isStatement(node) && isPlaceholder(node)) {
+ type = "statement";
+ } else {
+ type = "other";
+ }
+
+ const {
+ placeholders,
+ placeholderNames
+ } = state.isLegacyRef.value ? state.legacy : state.syntactic;
+ placeholders.push({
+ name,
+ type,
+ resolve: ast => resolveAncestors(ast, ancestors),
+ isDuplicate: placeholderNames.has(name)
+ });
+ placeholderNames.add(name);
+}
+
+function resolveAncestors(ast, ancestors) {
+ let parent = ast;
+
+ for (let i = 0; i < ancestors.length - 1; i++) {
+ const {
+ key,
+ index
+ } = ancestors[i];
+
+ if (index === undefined) {
+ parent = parent[key];
+ } else {
+ parent = parent[key][index];
+ }
+ }
+
+ const {
+ key,
+ index
+ } = ancestors[ancestors.length - 1];
+ return {
+ parent,
+ key,
+ index
+ };
+}
+
+function parseWithCodeFrame(code, parserOpts, syntacticPlaceholders) {
+ const plugins = (parserOpts.plugins || []).slice();
+
+ if (syntacticPlaceholders !== false) {
+ plugins.push("placeholders");
+ }
+
+ parserOpts = Object.assign({
+ allowReturnOutsideFunction: true,
+ allowSuperOutsideMethod: true,
+ sourceType: "module"
+ }, parserOpts, {
+ plugins
+ });
+
+ try {
+ return (0, _parser.parse)(code, parserOpts);
+ } catch (err) {
+ const loc = err.loc;
+
+ if (loc) {
+ err.message += "\n" + (0, _codeFrame.codeFrameColumns)(code, {
+ start: loc
+ });
+ err.code = "BABEL_TEMPLATE_PARSE_ERROR";
+ }
+
+ throw err;
+ }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/template/lib/populate.js b/node_modules/@babel/template/lib/populate.js
new file mode 100644
index 000000000..b9125564b
--- /dev/null
+++ b/node_modules/@babel/template/lib/populate.js
@@ -0,0 +1,135 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = populatePlaceholders;
+
+var _t = require("@babel/types");
+
+const {
+ blockStatement,
+ cloneNode,
+ emptyStatement,
+ expressionStatement,
+ identifier,
+ isStatement,
+ isStringLiteral,
+ stringLiteral,
+ validate
+} = _t;
+
+function populatePlaceholders(metadata, replacements) {
+ const ast = cloneNode(metadata.ast);
+
+ if (replacements) {
+ metadata.placeholders.forEach(placeholder => {
+ if (!Object.prototype.hasOwnProperty.call(replacements, placeholder.name)) {
+ const placeholderName = placeholder.name;
+ throw new Error(`Error: No substitution given for "${placeholderName}". If this is not meant to be a
+ placeholder you may want to consider passing one of the following options to @babel/template:
+ - { placeholderPattern: false, placeholderWhitelist: new Set(['${placeholderName}'])}
+ - { placeholderPattern: /^${placeholderName}$/ }`);
+ }
+ });
+ Object.keys(replacements).forEach(key => {
+ if (!metadata.placeholderNames.has(key)) {
+ throw new Error(`Unknown substitution "${key}" given`);
+ }
+ });
+ }
+
+ metadata.placeholders.slice().reverse().forEach(placeholder => {
+ try {
+ applyReplacement(placeholder, ast, replacements && replacements[placeholder.name] || null);
+ } catch (e) {
+ e.message = `@babel/template placeholder "${placeholder.name}": ${e.message}`;
+ throw e;
+ }
+ });
+ return ast;
+}
+
+function applyReplacement(placeholder, ast, replacement) {
+ if (placeholder.isDuplicate) {
+ if (Array.isArray(replacement)) {
+ replacement = replacement.map(node => cloneNode(node));
+ } else if (typeof replacement === "object") {
+ replacement = cloneNode(replacement);
+ }
+ }
+
+ const {
+ parent,
+ key,
+ index
+ } = placeholder.resolve(ast);
+
+ if (placeholder.type === "string") {
+ if (typeof replacement === "string") {
+ replacement = stringLiteral(replacement);
+ }
+
+ if (!replacement || !isStringLiteral(replacement)) {
+ throw new Error("Expected string substitution");
+ }
+ } else if (placeholder.type === "statement") {
+ if (index === undefined) {
+ if (!replacement) {
+ replacement = emptyStatement();
+ } else if (Array.isArray(replacement)) {
+ replacement = blockStatement(replacement);
+ } else if (typeof replacement === "string") {
+ replacement = expressionStatement(identifier(replacement));
+ } else if (!isStatement(replacement)) {
+ replacement = expressionStatement(replacement);
+ }
+ } else {
+ if (replacement && !Array.isArray(replacement)) {
+ if (typeof replacement === "string") {
+ replacement = identifier(replacement);
+ }
+
+ if (!isStatement(replacement)) {
+ replacement = expressionStatement(replacement);
+ }
+ }
+ }
+ } else if (placeholder.type === "param") {
+ if (typeof replacement === "string") {
+ replacement = identifier(replacement);
+ }
+
+ if (index === undefined) throw new Error("Assertion failure.");
+ } else {
+ if (typeof replacement === "string") {
+ replacement = identifier(replacement);
+ }
+
+ if (Array.isArray(replacement)) {
+ throw new Error("Cannot replace single expression with an array.");
+ }
+ }
+
+ if (index === undefined) {
+ validate(parent, key, replacement);
+ parent[key] = replacement;
+ } else {
+ const items = parent[key].slice();
+
+ if (placeholder.type === "statement" || placeholder.type === "param") {
+ if (replacement == null) {
+ items.splice(index, 1);
+ } else if (Array.isArray(replacement)) {
+ items.splice(index, 1, ...replacement);
+ } else {
+ items[index] = replacement;
+ }
+ } else {
+ items[index] = replacement;
+ }
+
+ validate(parent, key, items);
+ parent[key] = items;
+ }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/template/lib/string.js b/node_modules/@babel/template/lib/string.js
new file mode 100644
index 000000000..fa8aade53
--- /dev/null
+++ b/node_modules/@babel/template/lib/string.js
@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = stringTemplate;
+
+var _options = require("./options");
+
+var _parse = require("./parse");
+
+var _populate = require("./populate");
+
+function stringTemplate(formatter, code, opts) {
+ code = formatter.code(code);
+ let metadata;
+ return arg => {
+ const replacements = (0, _options.normalizeReplacements)(arg);
+ if (!metadata) metadata = (0, _parse.default)(formatter, code, opts);
+ return formatter.unwrap((0, _populate.default)(metadata, replacements));
+ };
+}
\ No newline at end of file
diff --git a/node_modules/@babel/template/package.json b/node_modules/@babel/template/package.json
new file mode 100644
index 000000000..9aca58a5a
--- /dev/null
+++ b/node_modules/@babel/template/package.json
@@ -0,0 +1,26 @@
+{
+ "name": "@babel/template",
+ "version": "7.16.7",
+ "description": "Generate an AST from a string template.",
+ "author": "The Babel Team (https://babel.dev/team)",
+ "homepage": "https://babel.dev/docs/en/next/babel-template",
+ "bugs": "https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20template%22+is%3Aopen",
+ "license": "MIT",
+ "publishConfig": {
+ "access": "public"
+ },
+ "repository": {
+ "type": "git",
+ "url": "https://github.com/babel/babel.git",
+ "directory": "packages/babel-template"
+ },
+ "main": "./lib/index.js",
+ "dependencies": {
+ "@babel/code-frame": "^7.16.7",
+ "@babel/parser": "^7.16.7",
+ "@babel/types": "^7.16.7"
+ },
+ "engines": {
+ "node": ">=6.9.0"
+ }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/LICENSE b/node_modules/@babel/traverse/LICENSE
new file mode 100644
index 000000000..f31575ec7
--- /dev/null
+++ b/node_modules/@babel/traverse/LICENSE
@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/node_modules/@babel/traverse/README.md b/node_modules/@babel/traverse/README.md
new file mode 100644
index 000000000..e478f16fb
--- /dev/null
+++ b/node_modules/@babel/traverse/README.md
@@ -0,0 +1,19 @@
+# @babel/traverse
+
+> The Babel Traverse module maintains the overall tree state, and is responsible for replacing, removing, and adding nodes
+
+See our website [@babel/traverse](https://babeljs.io/docs/en/babel-traverse) for more information or the [issues](https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20traverse%22+is%3Aopen) associated with this package.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save-dev @babel/traverse
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/traverse --dev
+```
diff --git a/node_modules/@babel/traverse/lib/cache.js b/node_modules/@babel/traverse/lib/cache.js
new file mode 100644
index 000000000..89f200777
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/cache.js
@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.clear = clear;
+exports.clearPath = clearPath;
+exports.clearScope = clearScope;
+exports.scope = exports.path = void 0;
+let path = new WeakMap();
+exports.path = path;
+let scope = new WeakMap();
+exports.scope = scope;
+
+function clear() {
+ clearPath();
+ clearScope();
+}
+
+function clearPath() {
+ exports.path = path = new WeakMap();
+}
+
+function clearScope() {
+ exports.scope = scope = new WeakMap();
+}
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/lib/context.js b/node_modules/@babel/traverse/lib/context.js
new file mode 100644
index 000000000..25e2e0a75
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/context.js
@@ -0,0 +1,137 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = void 0;
+
+var _path = require("./path");
+
+var _t = require("@babel/types");
+
+const {
+ VISITOR_KEYS
+} = _t;
+
+class TraversalContext {
+ constructor(scope, opts, state, parentPath) {
+ this.queue = null;
+ this.priorityQueue = null;
+ this.parentPath = parentPath;
+ this.scope = scope;
+ this.state = state;
+ this.opts = opts;
+ }
+
+ shouldVisit(node) {
+ const opts = this.opts;
+ if (opts.enter || opts.exit) return true;
+ if (opts[node.type]) return true;
+ const keys = VISITOR_KEYS[node.type];
+ if (!(keys != null && keys.length)) return false;
+
+ for (const key of keys) {
+ if (node[key]) return true;
+ }
+
+ return false;
+ }
+
+ create(node, obj, key, listKey) {
+ return _path.default.get({
+ parentPath: this.parentPath,
+ parent: node,
+ container: obj,
+ key: key,
+ listKey
+ });
+ }
+
+ maybeQueue(path, notPriority) {
+ if (this.queue) {
+ if (notPriority) {
+ this.queue.push(path);
+ } else {
+ this.priorityQueue.push(path);
+ }
+ }
+ }
+
+ visitMultiple(container, parent, listKey) {
+ if (container.length === 0) return false;
+ const queue = [];
+
+ for (let key = 0; key < container.length; key++) {
+ const node = container[key];
+
+ if (node && this.shouldVisit(node)) {
+ queue.push(this.create(parent, container, key, listKey));
+ }
+ }
+
+ return this.visitQueue(queue);
+ }
+
+ visitSingle(node, key) {
+ if (this.shouldVisit(node[key])) {
+ return this.visitQueue([this.create(node, node, key)]);
+ } else {
+ return false;
+ }
+ }
+
+ visitQueue(queue) {
+ this.queue = queue;
+ this.priorityQueue = [];
+ const visited = new WeakSet();
+ let stop = false;
+
+ for (const path of queue) {
+ path.resync();
+
+ if (path.contexts.length === 0 || path.contexts[path.contexts.length - 1] !== this) {
+ path.pushContext(this);
+ }
+
+ if (path.key === null) continue;
+ const {
+ node
+ } = path;
+ if (visited.has(node)) continue;
+ if (node) visited.add(node);
+
+ if (path.visit()) {
+ stop = true;
+ break;
+ }
+
+ if (this.priorityQueue.length) {
+ stop = this.visitQueue(this.priorityQueue);
+ this.priorityQueue = [];
+ this.queue = queue;
+ if (stop) break;
+ }
+ }
+
+ for (const path of queue) {
+ path.popContext();
+ }
+
+ this.queue = null;
+ return stop;
+ }
+
+ visit(node, key) {
+ const nodes = node[key];
+ if (!nodes) return false;
+
+ if (Array.isArray(nodes)) {
+ return this.visitMultiple(nodes, node, key);
+ } else {
+ return this.visitSingle(node, key);
+ }
+ }
+
+}
+
+exports.default = TraversalContext;
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/lib/hub.js b/node_modules/@babel/traverse/lib/hub.js
new file mode 100644
index 000000000..fe139d2a8
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/hub.js
@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = void 0;
+
+class Hub {
+ getCode() {}
+
+ getScope() {}
+
+ addHelper() {
+ throw new Error("Helpers are not supported by the default hub.");
+ }
+
+ buildError(node, msg, Error = TypeError) {
+ return new Error(msg);
+ }
+
+}
+
+exports.default = Hub;
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/lib/index.js b/node_modules/@babel/traverse/lib/index.js
new file mode 100644
index 000000000..44406786e
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/index.js
@@ -0,0 +1,111 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+Object.defineProperty(exports, "Hub", {
+ enumerable: true,
+ get: function () {
+ return _hub.default;
+ }
+});
+Object.defineProperty(exports, "NodePath", {
+ enumerable: true,
+ get: function () {
+ return _path.default;
+ }
+});
+Object.defineProperty(exports, "Scope", {
+ enumerable: true,
+ get: function () {
+ return _scope.default;
+ }
+});
+exports.visitors = exports.default = void 0;
+
+var visitors = require("./visitors");
+
+exports.visitors = visitors;
+
+var _t = require("@babel/types");
+
+var cache = require("./cache");
+
+var _traverseNode = require("./traverse-node");
+
+var _path = require("./path");
+
+var _scope = require("./scope");
+
+var _hub = require("./hub");
+
+const {
+ VISITOR_KEYS,
+ removeProperties,
+ traverseFast
+} = _t;
+
+function traverse(parent, opts = {}, scope, state, parentPath) {
+ if (!parent) return;
+
+ if (!opts.noScope && !scope) {
+ if (parent.type !== "Program" && parent.type !== "File") {
+ throw new Error("You must pass a scope and parentPath unless traversing a Program/File. " + `Instead of that you tried to traverse a ${parent.type} node without ` + "passing scope and parentPath.");
+ }
+ }
+
+ if (!VISITOR_KEYS[parent.type]) {
+ return;
+ }
+
+ visitors.explode(opts);
+ (0, _traverseNode.traverseNode)(parent, opts, scope, state, parentPath);
+}
+
+var _default = traverse;
+exports.default = _default;
+traverse.visitors = visitors;
+traverse.verify = visitors.verify;
+traverse.explode = visitors.explode;
+
+traverse.cheap = function (node, enter) {
+ return traverseFast(node, enter);
+};
+
+traverse.node = function (node, opts, scope, state, path, skipKeys) {
+ (0, _traverseNode.traverseNode)(node, opts, scope, state, path, skipKeys);
+};
+
+traverse.clearNode = function (node, opts) {
+ removeProperties(node, opts);
+ cache.path.delete(node);
+};
+
+traverse.removeProperties = function (tree, opts) {
+ traverseFast(tree, traverse.clearNode, opts);
+ return tree;
+};
+
+function hasDenylistedType(path, state) {
+ if (path.node.type === state.type) {
+ state.has = true;
+ path.stop();
+ }
+}
+
+traverse.hasType = function (tree, type, denylistTypes) {
+ if (denylistTypes != null && denylistTypes.includes(tree.type)) return false;
+ if (tree.type === type) return true;
+ const state = {
+ has: false,
+ type: type
+ };
+ traverse(tree, {
+ noScope: true,
+ denylist: denylistTypes,
+ enter: hasDenylistedType
+ }, null, state);
+ return state.has;
+};
+
+traverse.cache = cache;
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/lib/path/ancestry.js b/node_modules/@babel/traverse/lib/path/ancestry.js
new file mode 100644
index 000000000..23f672037
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/path/ancestry.js
@@ -0,0 +1,180 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.find = find;
+exports.findParent = findParent;
+exports.getAncestry = getAncestry;
+exports.getDeepestCommonAncestorFrom = getDeepestCommonAncestorFrom;
+exports.getEarliestCommonAncestorFrom = getEarliestCommonAncestorFrom;
+exports.getFunctionParent = getFunctionParent;
+exports.getStatementParent = getStatementParent;
+exports.inType = inType;
+exports.isAncestor = isAncestor;
+exports.isDescendant = isDescendant;
+
+var _t = require("@babel/types");
+
+var _index = require("./index");
+
+const {
+ VISITOR_KEYS
+} = _t;
+
+function findParent(callback) {
+ let path = this;
+
+ while (path = path.parentPath) {
+ if (callback(path)) return path;
+ }
+
+ return null;
+}
+
+function find(callback) {
+ let path = this;
+
+ do {
+ if (callback(path)) return path;
+ } while (path = path.parentPath);
+
+ return null;
+}
+
+function getFunctionParent() {
+ return this.findParent(p => p.isFunction());
+}
+
+function getStatementParent() {
+ let path = this;
+
+ do {
+ if (!path.parentPath || Array.isArray(path.container) && path.isStatement()) {
+ break;
+ } else {
+ path = path.parentPath;
+ }
+ } while (path);
+
+ if (path && (path.isProgram() || path.isFile())) {
+ throw new Error("File/Program node, we can't possibly find a statement parent to this");
+ }
+
+ return path;
+}
+
+function getEarliestCommonAncestorFrom(paths) {
+ return this.getDeepestCommonAncestorFrom(paths, function (deepest, i, ancestries) {
+ let earliest;
+ const keys = VISITOR_KEYS[deepest.type];
+
+ for (const ancestry of ancestries) {
+ const path = ancestry[i + 1];
+
+ if (!earliest) {
+ earliest = path;
+ continue;
+ }
+
+ if (path.listKey && earliest.listKey === path.listKey) {
+ if (path.key < earliest.key) {
+ earliest = path;
+ continue;
+ }
+ }
+
+ const earliestKeyIndex = keys.indexOf(earliest.parentKey);
+ const currentKeyIndex = keys.indexOf(path.parentKey);
+
+ if (earliestKeyIndex > currentKeyIndex) {
+ earliest = path;
+ }
+ }
+
+ return earliest;
+ });
+}
+
+function getDeepestCommonAncestorFrom(paths, filter) {
+ if (!paths.length) {
+ return this;
+ }
+
+ if (paths.length === 1) {
+ return paths[0];
+ }
+
+ let minDepth = Infinity;
+ let lastCommonIndex, lastCommon;
+ const ancestries = paths.map(path => {
+ const ancestry = [];
+
+ do {
+ ancestry.unshift(path);
+ } while ((path = path.parentPath) && path !== this);
+
+ if (ancestry.length < minDepth) {
+ minDepth = ancestry.length;
+ }
+
+ return ancestry;
+ });
+ const first = ancestries[0];
+
+ depthLoop: for (let i = 0; i < minDepth; i++) {
+ const shouldMatch = first[i];
+
+ for (const ancestry of ancestries) {
+ if (ancestry[i] !== shouldMatch) {
+ break depthLoop;
+ }
+ }
+
+ lastCommonIndex = i;
+ lastCommon = shouldMatch;
+ }
+
+ if (lastCommon) {
+ if (filter) {
+ return filter(lastCommon, lastCommonIndex, ancestries);
+ } else {
+ return lastCommon;
+ }
+ } else {
+ throw new Error("Couldn't find intersection");
+ }
+}
+
+function getAncestry() {
+ let path = this;
+ const paths = [];
+
+ do {
+ paths.push(path);
+ } while (path = path.parentPath);
+
+ return paths;
+}
+
+function isAncestor(maybeDescendant) {
+ return maybeDescendant.isDescendant(this);
+}
+
+function isDescendant(maybeAncestor) {
+ return !!this.findParent(parent => parent === maybeAncestor);
+}
+
+function inType(...candidateTypes) {
+ let path = this;
+
+ while (path) {
+ for (const type of candidateTypes) {
+ if (path.node.type === type) return true;
+ }
+
+ path = path.parentPath;
+ }
+
+ return false;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/lib/path/comments.js b/node_modules/@babel/traverse/lib/path/comments.js
new file mode 100644
index 000000000..d42bd29dd
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/path/comments.js
@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.addComment = addComment;
+exports.addComments = addComments;
+exports.shareCommentsWithSiblings = shareCommentsWithSiblings;
+
+var _t = require("@babel/types");
+
+const {
+ addComment: _addComment,
+ addComments: _addComments
+} = _t;
+
+function shareCommentsWithSiblings() {
+ if (typeof this.key === "string") return;
+ const node = this.node;
+ if (!node) return;
+ const trailing = node.trailingComments;
+ const leading = node.leadingComments;
+ if (!trailing && !leading) return;
+ const prev = this.getSibling(this.key - 1);
+ const next = this.getSibling(this.key + 1);
+ const hasPrev = Boolean(prev.node);
+ const hasNext = Boolean(next.node);
+
+ if (hasPrev && !hasNext) {
+ prev.addComments("trailing", trailing);
+ } else if (hasNext && !hasPrev) {
+ next.addComments("leading", leading);
+ }
+}
+
+function addComment(type, content, line) {
+ _addComment(this.node, type, content, line);
+}
+
+function addComments(type, comments) {
+ _addComments(this.node, type, comments);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/lib/path/context.js b/node_modules/@babel/traverse/lib/path/context.js
new file mode 100644
index 000000000..b11f08dc6
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/path/context.js
@@ -0,0 +1,263 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports._call = _call;
+exports._getQueueContexts = _getQueueContexts;
+exports._resyncKey = _resyncKey;
+exports._resyncList = _resyncList;
+exports._resyncParent = _resyncParent;
+exports._resyncRemoved = _resyncRemoved;
+exports.call = call;
+exports.isBlacklisted = exports.isDenylisted = isDenylisted;
+exports.popContext = popContext;
+exports.pushContext = pushContext;
+exports.requeue = requeue;
+exports.resync = resync;
+exports.setContext = setContext;
+exports.setKey = setKey;
+exports.setScope = setScope;
+exports.setup = setup;
+exports.skip = skip;
+exports.skipKey = skipKey;
+exports.stop = stop;
+exports.visit = visit;
+
+var _traverseNode = require("../traverse-node");
+
+var _index = require("./index");
+
+function call(key) {
+ const opts = this.opts;
+ this.debug(key);
+
+ if (this.node) {
+ if (this._call(opts[key])) return true;
+ }
+
+ if (this.node) {
+ return this._call(opts[this.node.type] && opts[this.node.type][key]);
+ }
+
+ return false;
+}
+
+function _call(fns) {
+ if (!fns) return false;
+
+ for (const fn of fns) {
+ if (!fn) continue;
+ const node = this.node;
+ if (!node) return true;
+ const ret = fn.call(this.state, this, this.state);
+
+ if (ret && typeof ret === "object" && typeof ret.then === "function") {
+ throw new Error(`You appear to be using a plugin with an async traversal visitor, ` + `which your current version of Babel does not support. ` + `If you're using a published plugin, you may need to upgrade ` + `your @babel/core version.`);
+ }
+
+ if (ret) {
+ throw new Error(`Unexpected return value from visitor method ${fn}`);
+ }
+
+ if (this.node !== node) return true;
+ if (this._traverseFlags > 0) return true;
+ }
+
+ return false;
+}
+
+function isDenylisted() {
+ var _this$opts$denylist;
+
+ const denylist = (_this$opts$denylist = this.opts.denylist) != null ? _this$opts$denylist : this.opts.blacklist;
+ return denylist && denylist.indexOf(this.node.type) > -1;
+}
+
+function restoreContext(path, context) {
+ if (path.context !== context) {
+ path.context = context;
+ path.state = context.state;
+ path.opts = context.opts;
+ }
+}
+
+function visit() {
+ if (!this.node) {
+ return false;
+ }
+
+ if (this.isDenylisted()) {
+ return false;
+ }
+
+ if (this.opts.shouldSkip && this.opts.shouldSkip(this)) {
+ return false;
+ }
+
+ const currentContext = this.context;
+
+ if (this.shouldSkip || this.call("enter")) {
+ this.debug("Skip...");
+ return this.shouldStop;
+ }
+
+ restoreContext(this, currentContext);
+ this.debug("Recursing into...");
+ this.shouldStop = (0, _traverseNode.traverseNode)(this.node, this.opts, this.scope, this.state, this, this.skipKeys);
+ restoreContext(this, currentContext);
+ this.call("exit");
+ return this.shouldStop;
+}
+
+function skip() {
+ this.shouldSkip = true;
+}
+
+function skipKey(key) {
+ if (this.skipKeys == null) {
+ this.skipKeys = {};
+ }
+
+ this.skipKeys[key] = true;
+}
+
+function stop() {
+ this._traverseFlags |= _index.SHOULD_SKIP | _index.SHOULD_STOP;
+}
+
+function setScope() {
+ if (this.opts && this.opts.noScope) return;
+ let path = this.parentPath;
+ if (this.key === "key" && path.isMethod()) path = path.parentPath;
+ let target;
+
+ while (path && !target) {
+ if (path.opts && path.opts.noScope) return;
+ target = path.scope;
+ path = path.parentPath;
+ }
+
+ this.scope = this.getScope(target);
+ if (this.scope) this.scope.init();
+}
+
+function setContext(context) {
+ if (this.skipKeys != null) {
+ this.skipKeys = {};
+ }
+
+ this._traverseFlags = 0;
+
+ if (context) {
+ this.context = context;
+ this.state = context.state;
+ this.opts = context.opts;
+ }
+
+ this.setScope();
+ return this;
+}
+
+function resync() {
+ if (this.removed) return;
+
+ this._resyncParent();
+
+ this._resyncList();
+
+ this._resyncKey();
+}
+
+function _resyncParent() {
+ if (this.parentPath) {
+ this.parent = this.parentPath.node;
+ }
+}
+
+function _resyncKey() {
+ if (!this.container) return;
+ if (this.node === this.container[this.key]) return;
+
+ if (Array.isArray(this.container)) {
+ for (let i = 0; i < this.container.length; i++) {
+ if (this.container[i] === this.node) {
+ return this.setKey(i);
+ }
+ }
+ } else {
+ for (const key of Object.keys(this.container)) {
+ if (this.container[key] === this.node) {
+ return this.setKey(key);
+ }
+ }
+ }
+
+ this.key = null;
+}
+
+function _resyncList() {
+ if (!this.parent || !this.inList) return;
+ const newContainer = this.parent[this.listKey];
+ if (this.container === newContainer) return;
+ this.container = newContainer || null;
+}
+
+function _resyncRemoved() {
+ if (this.key == null || !this.container || this.container[this.key] !== this.node) {
+ this._markRemoved();
+ }
+}
+
+function popContext() {
+ this.contexts.pop();
+
+ if (this.contexts.length > 0) {
+ this.setContext(this.contexts[this.contexts.length - 1]);
+ } else {
+ this.setContext(undefined);
+ }
+}
+
+function pushContext(context) {
+ this.contexts.push(context);
+ this.setContext(context);
+}
+
+function setup(parentPath, container, listKey, key) {
+ this.listKey = listKey;
+ this.container = container;
+ this.parentPath = parentPath || this.parentPath;
+ this.setKey(key);
+}
+
+function setKey(key) {
+ var _this$node;
+
+ this.key = key;
+ this.node = this.container[this.key];
+ this.type = (_this$node = this.node) == null ? void 0 : _this$node.type;
+}
+
+function requeue(pathToQueue = this) {
+ if (pathToQueue.removed) return;
+ ;
+ const contexts = this.contexts;
+
+ for (const context of contexts) {
+ context.maybeQueue(pathToQueue);
+ }
+}
+
+function _getQueueContexts() {
+ let path = this;
+ let contexts = this.contexts;
+
+ while (!contexts.length) {
+ path = path.parentPath;
+ if (!path) break;
+ contexts = path.contexts;
+ }
+
+ return contexts;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/lib/path/conversion.js b/node_modules/@babel/traverse/lib/path/conversion.js
new file mode 100644
index 000000000..a019d221f
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/path/conversion.js
@@ -0,0 +1,531 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.arrowFunctionToExpression = arrowFunctionToExpression;
+exports.arrowFunctionToShadowed = arrowFunctionToShadowed;
+exports.ensureBlock = ensureBlock;
+exports.toComputedKey = toComputedKey;
+exports.unwrapFunctionEnvironment = unwrapFunctionEnvironment;
+
+var _t = require("@babel/types");
+
+var _helperEnvironmentVisitor = require("@babel/helper-environment-visitor");
+
+var _helperFunctionName = require("@babel/helper-function-name");
+
+var _visitors = require("../visitors");
+
+const {
+ arrowFunctionExpression,
+ assignmentExpression,
+ binaryExpression,
+ blockStatement,
+ callExpression,
+ conditionalExpression,
+ expressionStatement,
+ identifier,
+ isIdentifier,
+ jsxIdentifier,
+ logicalExpression,
+ LOGICAL_OPERATORS,
+ memberExpression,
+ metaProperty,
+ numericLiteral,
+ objectExpression,
+ restElement,
+ returnStatement,
+ sequenceExpression,
+ spreadElement,
+ stringLiteral,
+ super: _super,
+ thisExpression,
+ toExpression,
+ unaryExpression
+} = _t;
+
+function toComputedKey() {
+ let key;
+
+ if (this.isMemberExpression()) {
+ key = this.node.property;
+ } else if (this.isProperty() || this.isMethod()) {
+ key = this.node.key;
+ } else {
+ throw new ReferenceError("todo");
+ }
+
+ if (!this.node.computed) {
+ if (isIdentifier(key)) key = stringLiteral(key.name);
+ }
+
+ return key;
+}
+
+function ensureBlock() {
+ const body = this.get("body");
+ const bodyNode = body.node;
+
+ if (Array.isArray(body)) {
+ throw new Error("Can't convert array path to a block statement");
+ }
+
+ if (!bodyNode) {
+ throw new Error("Can't convert node without a body");
+ }
+
+ if (body.isBlockStatement()) {
+ return bodyNode;
+ }
+
+ const statements = [];
+ let stringPath = "body";
+ let key;
+ let listKey;
+
+ if (body.isStatement()) {
+ listKey = "body";
+ key = 0;
+ statements.push(body.node);
+ } else {
+ stringPath += ".body.0";
+
+ if (this.isFunction()) {
+ key = "argument";
+ statements.push(returnStatement(body.node));
+ } else {
+ key = "expression";
+ statements.push(expressionStatement(body.node));
+ }
+ }
+
+ this.node.body = blockStatement(statements);
+ const parentPath = this.get(stringPath);
+ body.setup(parentPath, listKey ? parentPath.node[listKey] : parentPath.node, listKey, key);
+ return this.node;
+}
+
+function arrowFunctionToShadowed() {
+ if (!this.isArrowFunctionExpression()) return;
+ this.arrowFunctionToExpression();
+}
+
+function unwrapFunctionEnvironment() {
+ if (!this.isArrowFunctionExpression() && !this.isFunctionExpression() && !this.isFunctionDeclaration()) {
+ throw this.buildCodeFrameError("Can only unwrap the environment of a function.");
+ }
+
+ hoistFunctionEnvironment(this);
+}
+
+function arrowFunctionToExpression({
+ allowInsertArrow = true,
+ specCompliant = false,
+ noNewArrows = !specCompliant
+} = {}) {
+ if (!this.isArrowFunctionExpression()) {
+ throw this.buildCodeFrameError("Cannot convert non-arrow function to a function expression.");
+ }
+
+ const {
+ thisBinding,
+ fnPath: fn
+ } = hoistFunctionEnvironment(this, noNewArrows, allowInsertArrow);
+ fn.ensureBlock();
+ fn.node.type = "FunctionExpression";
+
+ if (!noNewArrows) {
+ const checkBinding = thisBinding ? null : fn.scope.generateUidIdentifier("arrowCheckId");
+
+ if (checkBinding) {
+ fn.parentPath.scope.push({
+ id: checkBinding,
+ init: objectExpression([])
+ });
+ }
+
+ fn.get("body").unshiftContainer("body", expressionStatement(callExpression(this.hub.addHelper("newArrowCheck"), [thisExpression(), checkBinding ? identifier(checkBinding.name) : identifier(thisBinding)])));
+ fn.replaceWith(callExpression(memberExpression((0, _helperFunctionName.default)(this, true) || fn.node, identifier("bind")), [checkBinding ? identifier(checkBinding.name) : thisExpression()]));
+ }
+}
+
+const getSuperCallsVisitor = (0, _visitors.merge)([{
+ CallExpression(child, {
+ allSuperCalls
+ }) {
+ if (!child.get("callee").isSuper()) return;
+ allSuperCalls.push(child);
+ }
+
+}, _helperEnvironmentVisitor.default]);
+
+function hoistFunctionEnvironment(fnPath, noNewArrows = true, allowInsertArrow = true) {
+ let arrowParent;
+ let thisEnvFn = fnPath.findParent(p => {
+ if (p.isArrowFunctionExpression()) {
+ var _arrowParent;
+
+ (_arrowParent = arrowParent) != null ? _arrowParent : arrowParent = p;
+ return false;
+ }
+
+ return p.isFunction() || p.isProgram() || p.isClassProperty({
+ static: false
+ }) || p.isClassPrivateProperty({
+ static: false
+ });
+ });
+ const inConstructor = thisEnvFn.isClassMethod({
+ kind: "constructor"
+ });
+
+ if (thisEnvFn.isClassProperty() || thisEnvFn.isClassPrivateProperty()) {
+ if (arrowParent) {
+ thisEnvFn = arrowParent;
+ } else if (allowInsertArrow) {
+ fnPath.replaceWith(callExpression(arrowFunctionExpression([], toExpression(fnPath.node)), []));
+ thisEnvFn = fnPath.get("callee");
+ fnPath = thisEnvFn.get("body");
+ } else {
+ throw fnPath.buildCodeFrameError("Unable to transform arrow inside class property");
+ }
+ }
+
+ const {
+ thisPaths,
+ argumentsPaths,
+ newTargetPaths,
+ superProps,
+ superCalls
+ } = getScopeInformation(fnPath);
+
+ if (inConstructor && superCalls.length > 0) {
+ if (!allowInsertArrow) {
+ throw superCalls[0].buildCodeFrameError("Unable to handle nested super() usage in arrow");
+ }
+
+ const allSuperCalls = [];
+ thisEnvFn.traverse(getSuperCallsVisitor, {
+ allSuperCalls
+ });
+ const superBinding = getSuperBinding(thisEnvFn);
+ allSuperCalls.forEach(superCall => {
+ const callee = identifier(superBinding);
+ callee.loc = superCall.node.callee.loc;
+ superCall.get("callee").replaceWith(callee);
+ });
+ }
+
+ if (argumentsPaths.length > 0) {
+ const argumentsBinding = getBinding(thisEnvFn, "arguments", () => {
+ const args = () => identifier("arguments");
+
+ if (thisEnvFn.scope.path.isProgram()) {
+ return conditionalExpression(binaryExpression("===", unaryExpression("typeof", args()), stringLiteral("undefined")), thisEnvFn.scope.buildUndefinedNode(), args());
+ } else {
+ return args();
+ }
+ });
+ argumentsPaths.forEach(argumentsChild => {
+ const argsRef = identifier(argumentsBinding);
+ argsRef.loc = argumentsChild.node.loc;
+ argumentsChild.replaceWith(argsRef);
+ });
+ }
+
+ if (newTargetPaths.length > 0) {
+ const newTargetBinding = getBinding(thisEnvFn, "newtarget", () => metaProperty(identifier("new"), identifier("target")));
+ newTargetPaths.forEach(targetChild => {
+ const targetRef = identifier(newTargetBinding);
+ targetRef.loc = targetChild.node.loc;
+ targetChild.replaceWith(targetRef);
+ });
+ }
+
+ if (superProps.length > 0) {
+ if (!allowInsertArrow) {
+ throw superProps[0].buildCodeFrameError("Unable to handle nested super.prop usage");
+ }
+
+ const flatSuperProps = superProps.reduce((acc, superProp) => acc.concat(standardizeSuperProperty(superProp)), []);
+ flatSuperProps.forEach(superProp => {
+ const key = superProp.node.computed ? "" : superProp.get("property").node.name;
+ const isAssignment = superProp.parentPath.isAssignmentExpression({
+ left: superProp.node
+ });
+ const isCall = superProp.parentPath.isCallExpression({
+ callee: superProp.node
+ });
+ const superBinding = getSuperPropBinding(thisEnvFn, isAssignment, key);
+ const args = [];
+
+ if (superProp.node.computed) {
+ args.push(superProp.get("property").node);
+ }
+
+ if (isAssignment) {
+ const value = superProp.parentPath.node.right;
+ args.push(value);
+ }
+
+ const call = callExpression(identifier(superBinding), args);
+
+ if (isCall) {
+ superProp.parentPath.unshiftContainer("arguments", thisExpression());
+ superProp.replaceWith(memberExpression(call, identifier("call")));
+ thisPaths.push(superProp.parentPath.get("arguments.0"));
+ } else if (isAssignment) {
+ superProp.parentPath.replaceWith(call);
+ } else {
+ superProp.replaceWith(call);
+ }
+ });
+ }
+
+ let thisBinding;
+
+ if (thisPaths.length > 0 || !noNewArrows) {
+ thisBinding = getThisBinding(thisEnvFn, inConstructor);
+
+ if (noNewArrows || inConstructor && hasSuperClass(thisEnvFn)) {
+ thisPaths.forEach(thisChild => {
+ const thisRef = thisChild.isJSX() ? jsxIdentifier(thisBinding) : identifier(thisBinding);
+ thisRef.loc = thisChild.node.loc;
+ thisChild.replaceWith(thisRef);
+ });
+ if (!noNewArrows) thisBinding = null;
+ }
+ }
+
+ return {
+ thisBinding,
+ fnPath
+ };
+}
+
+function isLogicalOp(op) {
+ return LOGICAL_OPERATORS.includes(op);
+}
+
+function standardizeSuperProperty(superProp) {
+ if (superProp.parentPath.isAssignmentExpression() && superProp.parentPath.node.operator !== "=") {
+ const assignmentPath = superProp.parentPath;
+ const op = assignmentPath.node.operator.slice(0, -1);
+ const value = assignmentPath.node.right;
+ const isLogicalAssignment = isLogicalOp(op);
+
+ if (superProp.node.computed) {
+ const tmp = superProp.scope.generateDeclaredUidIdentifier("tmp");
+ const object = superProp.node.object;
+ const property = superProp.node.property;
+ assignmentPath.get("left").replaceWith(memberExpression(object, assignmentExpression("=", tmp, property), true));
+ assignmentPath.get("right").replaceWith(rightExpression(isLogicalAssignment ? "=" : op, memberExpression(object, identifier(tmp.name), true), value));
+ } else {
+ const object = superProp.node.object;
+ const property = superProp.node.property;
+ assignmentPath.get("left").replaceWith(memberExpression(object, property));
+ assignmentPath.get("right").replaceWith(rightExpression(isLogicalAssignment ? "=" : op, memberExpression(object, identifier(property.name)), value));
+ }
+
+ if (isLogicalAssignment) {
+ assignmentPath.replaceWith(logicalExpression(op, assignmentPath.node.left, assignmentPath.node.right));
+ } else {
+ assignmentPath.node.operator = "=";
+ }
+
+ return [assignmentPath.get("left"), assignmentPath.get("right").get("left")];
+ } else if (superProp.parentPath.isUpdateExpression()) {
+ const updateExpr = superProp.parentPath;
+ const tmp = superProp.scope.generateDeclaredUidIdentifier("tmp");
+ const computedKey = superProp.node.computed ? superProp.scope.generateDeclaredUidIdentifier("prop") : null;
+ const parts = [assignmentExpression("=", tmp, memberExpression(superProp.node.object, computedKey ? assignmentExpression("=", computedKey, superProp.node.property) : superProp.node.property, superProp.node.computed)), assignmentExpression("=", memberExpression(superProp.node.object, computedKey ? identifier(computedKey.name) : superProp.node.property, superProp.node.computed), binaryExpression(superProp.parentPath.node.operator[0], identifier(tmp.name), numericLiteral(1)))];
+
+ if (!superProp.parentPath.node.prefix) {
+ parts.push(identifier(tmp.name));
+ }
+
+ updateExpr.replaceWith(sequenceExpression(parts));
+ const left = updateExpr.get("expressions.0.right");
+ const right = updateExpr.get("expressions.1.left");
+ return [left, right];
+ }
+
+ return [superProp];
+
+ function rightExpression(op, left, right) {
+ if (op === "=") {
+ return assignmentExpression("=", left, right);
+ } else {
+ return binaryExpression(op, left, right);
+ }
+ }
+}
+
+function hasSuperClass(thisEnvFn) {
+ return thisEnvFn.isClassMethod() && !!thisEnvFn.parentPath.parentPath.node.superClass;
+}
+
+const assignSuperThisVisitor = (0, _visitors.merge)([{
+ CallExpression(child, {
+ supers,
+ thisBinding
+ }) {
+ if (!child.get("callee").isSuper()) return;
+ if (supers.has(child.node)) return;
+ supers.add(child.node);
+ child.replaceWithMultiple([child.node, assignmentExpression("=", identifier(thisBinding), identifier("this"))]);
+ }
+
+}, _helperEnvironmentVisitor.default]);
+
+function getThisBinding(thisEnvFn, inConstructor) {
+ return getBinding(thisEnvFn, "this", thisBinding => {
+ if (!inConstructor || !hasSuperClass(thisEnvFn)) return thisExpression();
+ thisEnvFn.traverse(assignSuperThisVisitor, {
+ supers: new WeakSet(),
+ thisBinding
+ });
+ });
+}
+
+function getSuperBinding(thisEnvFn) {
+ return getBinding(thisEnvFn, "supercall", () => {
+ const argsBinding = thisEnvFn.scope.generateUidIdentifier("args");
+ return arrowFunctionExpression([restElement(argsBinding)], callExpression(_super(), [spreadElement(identifier(argsBinding.name))]));
+ });
+}
+
+function getSuperPropBinding(thisEnvFn, isAssignment, propName) {
+ const op = isAssignment ? "set" : "get";
+ return getBinding(thisEnvFn, `superprop_${op}:${propName || ""}`, () => {
+ const argsList = [];
+ let fnBody;
+
+ if (propName) {
+ fnBody = memberExpression(_super(), identifier(propName));
+ } else {
+ const method = thisEnvFn.scope.generateUidIdentifier("prop");
+ argsList.unshift(method);
+ fnBody = memberExpression(_super(), identifier(method.name), true);
+ }
+
+ if (isAssignment) {
+ const valueIdent = thisEnvFn.scope.generateUidIdentifier("value");
+ argsList.push(valueIdent);
+ fnBody = assignmentExpression("=", fnBody, identifier(valueIdent.name));
+ }
+
+ return arrowFunctionExpression(argsList, fnBody);
+ });
+}
+
+function getBinding(thisEnvFn, key, init) {
+ const cacheKey = "binding:" + key;
+ let data = thisEnvFn.getData(cacheKey);
+
+ if (!data) {
+ const id = thisEnvFn.scope.generateUidIdentifier(key);
+ data = id.name;
+ thisEnvFn.setData(cacheKey, data);
+ thisEnvFn.scope.push({
+ id: id,
+ init: init(data)
+ });
+ }
+
+ return data;
+}
+
+const getScopeInformationVisitor = (0, _visitors.merge)([{
+ ThisExpression(child, {
+ thisPaths
+ }) {
+ thisPaths.push(child);
+ },
+
+ JSXIdentifier(child, {
+ thisPaths
+ }) {
+ if (child.node.name !== "this") return;
+
+ if (!child.parentPath.isJSXMemberExpression({
+ object: child.node
+ }) && !child.parentPath.isJSXOpeningElement({
+ name: child.node
+ })) {
+ return;
+ }
+
+ thisPaths.push(child);
+ },
+
+ CallExpression(child, {
+ superCalls
+ }) {
+ if (child.get("callee").isSuper()) superCalls.push(child);
+ },
+
+ MemberExpression(child, {
+ superProps
+ }) {
+ if (child.get("object").isSuper()) superProps.push(child);
+ },
+
+ Identifier(child, {
+ argumentsPaths
+ }) {
+ if (!child.isReferencedIdentifier({
+ name: "arguments"
+ })) return;
+ let curr = child.scope;
+
+ do {
+ if (curr.hasOwnBinding("arguments")) {
+ curr.rename("arguments");
+ return;
+ }
+
+ if (curr.path.isFunction() && !curr.path.isArrowFunctionExpression()) {
+ break;
+ }
+ } while (curr = curr.parent);
+
+ argumentsPaths.push(child);
+ },
+
+ MetaProperty(child, {
+ newTargetPaths
+ }) {
+ if (!child.get("meta").isIdentifier({
+ name: "new"
+ })) return;
+ if (!child.get("property").isIdentifier({
+ name: "target"
+ })) return;
+ newTargetPaths.push(child);
+ }
+
+}, _helperEnvironmentVisitor.default]);
+
+function getScopeInformation(fnPath) {
+ const thisPaths = [];
+ const argumentsPaths = [];
+ const newTargetPaths = [];
+ const superProps = [];
+ const superCalls = [];
+ fnPath.traverse(getScopeInformationVisitor, {
+ thisPaths,
+ argumentsPaths,
+ newTargetPaths,
+ superProps,
+ superCalls
+ });
+ return {
+ thisPaths,
+ argumentsPaths,
+ newTargetPaths,
+ superProps,
+ superCalls
+ };
+}
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/lib/path/evaluation.js b/node_modules/@babel/traverse/lib/path/evaluation.js
new file mode 100644
index 000000000..abbbe050f
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/path/evaluation.js
@@ -0,0 +1,401 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.evaluate = evaluate;
+exports.evaluateTruthy = evaluateTruthy;
+const VALID_CALLEES = ["String", "Number", "Math"];
+const INVALID_METHODS = ["random"];
+
+function evaluateTruthy() {
+ const res = this.evaluate();
+ if (res.confident) return !!res.value;
+}
+
+function deopt(path, state) {
+ if (!state.confident) return;
+ state.deoptPath = path;
+ state.confident = false;
+}
+
+function evaluateCached(path, state) {
+ const {
+ node
+ } = path;
+ const {
+ seen
+ } = state;
+
+ if (seen.has(node)) {
+ const existing = seen.get(node);
+
+ if (existing.resolved) {
+ return existing.value;
+ } else {
+ deopt(path, state);
+ return;
+ }
+ } else {
+ const item = {
+ resolved: false
+ };
+ seen.set(node, item);
+
+ const val = _evaluate(path, state);
+
+ if (state.confident) {
+ item.resolved = true;
+ item.value = val;
+ }
+
+ return val;
+ }
+}
+
+function _evaluate(path, state) {
+ if (!state.confident) return;
+
+ if (path.isSequenceExpression()) {
+ const exprs = path.get("expressions");
+ return evaluateCached(exprs[exprs.length - 1], state);
+ }
+
+ if (path.isStringLiteral() || path.isNumericLiteral() || path.isBooleanLiteral()) {
+ return path.node.value;
+ }
+
+ if (path.isNullLiteral()) {
+ return null;
+ }
+
+ if (path.isTemplateLiteral()) {
+ return evaluateQuasis(path, path.node.quasis, state);
+ }
+
+ if (path.isTaggedTemplateExpression() && path.get("tag").isMemberExpression()) {
+ const object = path.get("tag.object");
+ const {
+ node: {
+ name
+ }
+ } = object;
+ const property = path.get("tag.property");
+
+ if (object.isIdentifier() && name === "String" && !path.scope.getBinding(name) && property.isIdentifier() && property.node.name === "raw") {
+ return evaluateQuasis(path, path.node.quasi.quasis, state, true);
+ }
+ }
+
+ if (path.isConditionalExpression()) {
+ const testResult = evaluateCached(path.get("test"), state);
+ if (!state.confident) return;
+
+ if (testResult) {
+ return evaluateCached(path.get("consequent"), state);
+ } else {
+ return evaluateCached(path.get("alternate"), state);
+ }
+ }
+
+ if (path.isExpressionWrapper()) {
+ return evaluateCached(path.get("expression"), state);
+ }
+
+ if (path.isMemberExpression() && !path.parentPath.isCallExpression({
+ callee: path.node
+ })) {
+ const property = path.get("property");
+ const object = path.get("object");
+
+ if (object.isLiteral() && property.isIdentifier()) {
+ const value = object.node.value;
+ const type = typeof value;
+
+ if (type === "number" || type === "string") {
+ return value[property.node.name];
+ }
+ }
+ }
+
+ if (path.isReferencedIdentifier()) {
+ const binding = path.scope.getBinding(path.node.name);
+
+ if (binding && binding.constantViolations.length > 0) {
+ return deopt(binding.path, state);
+ }
+
+ if (binding && path.node.start < binding.path.node.end) {
+ return deopt(binding.path, state);
+ }
+
+ if (binding != null && binding.hasValue) {
+ return binding.value;
+ } else {
+ if (path.node.name === "undefined") {
+ return binding ? deopt(binding.path, state) : undefined;
+ } else if (path.node.name === "Infinity") {
+ return binding ? deopt(binding.path, state) : Infinity;
+ } else if (path.node.name === "NaN") {
+ return binding ? deopt(binding.path, state) : NaN;
+ }
+
+ const resolved = path.resolve();
+
+ if (resolved === path) {
+ return deopt(path, state);
+ } else {
+ return evaluateCached(resolved, state);
+ }
+ }
+ }
+
+ if (path.isUnaryExpression({
+ prefix: true
+ })) {
+ if (path.node.operator === "void") {
+ return undefined;
+ }
+
+ const argument = path.get("argument");
+
+ if (path.node.operator === "typeof" && (argument.isFunction() || argument.isClass())) {
+ return "function";
+ }
+
+ const arg = evaluateCached(argument, state);
+ if (!state.confident) return;
+
+ switch (path.node.operator) {
+ case "!":
+ return !arg;
+
+ case "+":
+ return +arg;
+
+ case "-":
+ return -arg;
+
+ case "~":
+ return ~arg;
+
+ case "typeof":
+ return typeof arg;
+ }
+ }
+
+ if (path.isArrayExpression()) {
+ const arr = [];
+ const elems = path.get("elements");
+
+ for (const elem of elems) {
+ const elemValue = elem.evaluate();
+
+ if (elemValue.confident) {
+ arr.push(elemValue.value);
+ } else {
+ return deopt(elemValue.deopt, state);
+ }
+ }
+
+ return arr;
+ }
+
+ if (path.isObjectExpression()) {
+ const obj = {};
+ const props = path.get("properties");
+
+ for (const prop of props) {
+ if (prop.isObjectMethod() || prop.isSpreadElement()) {
+ return deopt(prop, state);
+ }
+
+ const keyPath = prop.get("key");
+ let key = keyPath;
+
+ if (prop.node.computed) {
+ key = key.evaluate();
+
+ if (!key.confident) {
+ return deopt(key.deopt, state);
+ }
+
+ key = key.value;
+ } else if (key.isIdentifier()) {
+ key = key.node.name;
+ } else {
+ key = key.node.value;
+ }
+
+ const valuePath = prop.get("value");
+ let value = valuePath.evaluate();
+
+ if (!value.confident) {
+ return deopt(value.deopt, state);
+ }
+
+ value = value.value;
+ obj[key] = value;
+ }
+
+ return obj;
+ }
+
+ if (path.isLogicalExpression()) {
+ const wasConfident = state.confident;
+ const left = evaluateCached(path.get("left"), state);
+ const leftConfident = state.confident;
+ state.confident = wasConfident;
+ const right = evaluateCached(path.get("right"), state);
+ const rightConfident = state.confident;
+
+ switch (path.node.operator) {
+ case "||":
+ state.confident = leftConfident && (!!left || rightConfident);
+ if (!state.confident) return;
+ return left || right;
+
+ case "&&":
+ state.confident = leftConfident && (!left || rightConfident);
+ if (!state.confident) return;
+ return left && right;
+ }
+ }
+
+ if (path.isBinaryExpression()) {
+ const left = evaluateCached(path.get("left"), state);
+ if (!state.confident) return;
+ const right = evaluateCached(path.get("right"), state);
+ if (!state.confident) return;
+
+ switch (path.node.operator) {
+ case "-":
+ return left - right;
+
+ case "+":
+ return left + right;
+
+ case "/":
+ return left / right;
+
+ case "*":
+ return left * right;
+
+ case "%":
+ return left % right;
+
+ case "**":
+ return Math.pow(left, right);
+
+ case "<":
+ return left < right;
+
+ case ">":
+ return left > right;
+
+ case "<=":
+ return left <= right;
+
+ case ">=":
+ return left >= right;
+
+ case "==":
+ return left == right;
+
+ case "!=":
+ return left != right;
+
+ case "===":
+ return left === right;
+
+ case "!==":
+ return left !== right;
+
+ case "|":
+ return left | right;
+
+ case "&":
+ return left & right;
+
+ case "^":
+ return left ^ right;
+
+ case "<<":
+ return left << right;
+
+ case ">>":
+ return left >> right;
+
+ case ">>>":
+ return left >>> right;
+ }
+ }
+
+ if (path.isCallExpression()) {
+ const callee = path.get("callee");
+ let context;
+ let func;
+
+ if (callee.isIdentifier() && !path.scope.getBinding(callee.node.name) && VALID_CALLEES.indexOf(callee.node.name) >= 0) {
+ func = global[callee.node.name];
+ }
+
+ if (callee.isMemberExpression()) {
+ const object = callee.get("object");
+ const property = callee.get("property");
+
+ if (object.isIdentifier() && property.isIdentifier() && VALID_CALLEES.indexOf(object.node.name) >= 0 && INVALID_METHODS.indexOf(property.node.name) < 0) {
+ context = global[object.node.name];
+ func = context[property.node.name];
+ }
+
+ if (object.isLiteral() && property.isIdentifier()) {
+ const type = typeof object.node.value;
+
+ if (type === "string" || type === "number") {
+ context = object.node.value;
+ func = context[property.node.name];
+ }
+ }
+ }
+
+ if (func) {
+ const args = path.get("arguments").map(arg => evaluateCached(arg, state));
+ if (!state.confident) return;
+ return func.apply(context, args);
+ }
+ }
+
+ deopt(path, state);
+}
+
+function evaluateQuasis(path, quasis, state, raw = false) {
+ let str = "";
+ let i = 0;
+ const exprs = path.get("expressions");
+
+ for (const elem of quasis) {
+ if (!state.confident) break;
+ str += raw ? elem.value.raw : elem.value.cooked;
+ const expr = exprs[i++];
+ if (expr) str += String(evaluateCached(expr, state));
+ }
+
+ if (!state.confident) return;
+ return str;
+}
+
+function evaluate() {
+ const state = {
+ confident: true,
+ deoptPath: null,
+ seen: new Map()
+ };
+ let value = evaluateCached(this, state);
+ if (!state.confident) value = undefined;
+ return {
+ confident: state.confident,
+ deopt: state.deoptPath,
+ value: value
+ };
+}
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/lib/path/family.js b/node_modules/@babel/traverse/lib/path/family.js
new file mode 100644
index 000000000..6a6554bcd
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/path/family.js
@@ -0,0 +1,407 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports._getKey = _getKey;
+exports._getPattern = _getPattern;
+exports.get = get;
+exports.getAllNextSiblings = getAllNextSiblings;
+exports.getAllPrevSiblings = getAllPrevSiblings;
+exports.getBindingIdentifierPaths = getBindingIdentifierPaths;
+exports.getBindingIdentifiers = getBindingIdentifiers;
+exports.getCompletionRecords = getCompletionRecords;
+exports.getNextSibling = getNextSibling;
+exports.getOpposite = getOpposite;
+exports.getOuterBindingIdentifierPaths = getOuterBindingIdentifierPaths;
+exports.getOuterBindingIdentifiers = getOuterBindingIdentifiers;
+exports.getPrevSibling = getPrevSibling;
+exports.getSibling = getSibling;
+
+var _index = require("./index");
+
+var _t = require("@babel/types");
+
+const {
+ getBindingIdentifiers: _getBindingIdentifiers,
+ getOuterBindingIdentifiers: _getOuterBindingIdentifiers,
+ isDeclaration,
+ numericLiteral,
+ unaryExpression
+} = _t;
+const NORMAL_COMPLETION = 0;
+const BREAK_COMPLETION = 1;
+
+function NormalCompletion(path) {
+ return {
+ type: NORMAL_COMPLETION,
+ path
+ };
+}
+
+function BreakCompletion(path) {
+ return {
+ type: BREAK_COMPLETION,
+ path
+ };
+}
+
+function getOpposite() {
+ if (this.key === "left") {
+ return this.getSibling("right");
+ } else if (this.key === "right") {
+ return this.getSibling("left");
+ }
+
+ return null;
+}
+
+function addCompletionRecords(path, records, context) {
+ if (path) {
+ records.push(..._getCompletionRecords(path, context));
+ }
+
+ return records;
+}
+
+function completionRecordForSwitch(cases, records, context) {
+ let lastNormalCompletions = [];
+
+ for (let i = 0; i < cases.length; i++) {
+ const casePath = cases[i];
+
+ const caseCompletions = _getCompletionRecords(casePath, context);
+
+ const normalCompletions = [];
+ const breakCompletions = [];
+
+ for (const c of caseCompletions) {
+ if (c.type === NORMAL_COMPLETION) {
+ normalCompletions.push(c);
+ }
+
+ if (c.type === BREAK_COMPLETION) {
+ breakCompletions.push(c);
+ }
+ }
+
+ if (normalCompletions.length) {
+ lastNormalCompletions = normalCompletions;
+ }
+
+ records.push(...breakCompletions);
+ }
+
+ records.push(...lastNormalCompletions);
+ return records;
+}
+
+function normalCompletionToBreak(completions) {
+ completions.forEach(c => {
+ c.type = BREAK_COMPLETION;
+ });
+}
+
+function replaceBreakStatementInBreakCompletion(completions, reachable) {
+ completions.forEach(c => {
+ if (c.path.isBreakStatement({
+ label: null
+ })) {
+ if (reachable) {
+ c.path.replaceWith(unaryExpression("void", numericLiteral(0)));
+ } else {
+ c.path.remove();
+ }
+ }
+ });
+}
+
+function getStatementListCompletion(paths, context) {
+ const completions = [];
+
+ if (context.canHaveBreak) {
+ let lastNormalCompletions = [];
+
+ for (let i = 0; i < paths.length; i++) {
+ const path = paths[i];
+ const newContext = Object.assign({}, context, {
+ inCaseClause: false
+ });
+
+ if (path.isBlockStatement() && (context.inCaseClause || context.shouldPopulateBreak)) {
+ newContext.shouldPopulateBreak = true;
+ } else {
+ newContext.shouldPopulateBreak = false;
+ }
+
+ const statementCompletions = _getCompletionRecords(path, newContext);
+
+ if (statementCompletions.length > 0 && statementCompletions.every(c => c.type === BREAK_COMPLETION)) {
+ if (lastNormalCompletions.length > 0 && statementCompletions.every(c => c.path.isBreakStatement({
+ label: null
+ }))) {
+ normalCompletionToBreak(lastNormalCompletions);
+ completions.push(...lastNormalCompletions);
+
+ if (lastNormalCompletions.some(c => c.path.isDeclaration())) {
+ completions.push(...statementCompletions);
+ replaceBreakStatementInBreakCompletion(statementCompletions, true);
+ }
+
+ replaceBreakStatementInBreakCompletion(statementCompletions, false);
+ } else {
+ completions.push(...statementCompletions);
+
+ if (!context.shouldPopulateBreak) {
+ replaceBreakStatementInBreakCompletion(statementCompletions, true);
+ }
+ }
+
+ break;
+ }
+
+ if (i === paths.length - 1) {
+ completions.push(...statementCompletions);
+ } else {
+ lastNormalCompletions = [];
+
+ for (let i = 0; i < statementCompletions.length; i++) {
+ const c = statementCompletions[i];
+
+ if (c.type === BREAK_COMPLETION) {
+ completions.push(c);
+ }
+
+ if (c.type === NORMAL_COMPLETION) {
+ lastNormalCompletions.push(c);
+ }
+ }
+ }
+ }
+ } else if (paths.length) {
+ for (let i = paths.length - 1; i >= 0; i--) {
+ const pathCompletions = _getCompletionRecords(paths[i], context);
+
+ if (pathCompletions.length > 1 || pathCompletions.length === 1 && !pathCompletions[0].path.isVariableDeclaration()) {
+ completions.push(...pathCompletions);
+ break;
+ }
+ }
+ }
+
+ return completions;
+}
+
+function _getCompletionRecords(path, context) {
+ let records = [];
+
+ if (path.isIfStatement()) {
+ records = addCompletionRecords(path.get("consequent"), records, context);
+ records = addCompletionRecords(path.get("alternate"), records, context);
+ } else if (path.isDoExpression() || path.isFor() || path.isWhile() || path.isLabeledStatement()) {
+ return addCompletionRecords(path.get("body"), records, context);
+ } else if (path.isProgram() || path.isBlockStatement()) {
+ return getStatementListCompletion(path.get("body"), context);
+ } else if (path.isFunction()) {
+ return _getCompletionRecords(path.get("body"), context);
+ } else if (path.isTryStatement()) {
+ records = addCompletionRecords(path.get("block"), records, context);
+ records = addCompletionRecords(path.get("handler"), records, context);
+ } else if (path.isCatchClause()) {
+ return addCompletionRecords(path.get("body"), records, context);
+ } else if (path.isSwitchStatement()) {
+ return completionRecordForSwitch(path.get("cases"), records, context);
+ } else if (path.isSwitchCase()) {
+ return getStatementListCompletion(path.get("consequent"), {
+ canHaveBreak: true,
+ shouldPopulateBreak: false,
+ inCaseClause: true
+ });
+ } else if (path.isBreakStatement()) {
+ records.push(BreakCompletion(path));
+ } else {
+ records.push(NormalCompletion(path));
+ }
+
+ return records;
+}
+
+function getCompletionRecords() {
+ const records = _getCompletionRecords(this, {
+ canHaveBreak: false,
+ shouldPopulateBreak: false,
+ inCaseClause: false
+ });
+
+ return records.map(r => r.path);
+}
+
+function getSibling(key) {
+ return _index.default.get({
+ parentPath: this.parentPath,
+ parent: this.parent,
+ container: this.container,
+ listKey: this.listKey,
+ key: key
+ }).setContext(this.context);
+}
+
+function getPrevSibling() {
+ return this.getSibling(this.key - 1);
+}
+
+function getNextSibling() {
+ return this.getSibling(this.key + 1);
+}
+
+function getAllNextSiblings() {
+ let _key = this.key;
+ let sibling = this.getSibling(++_key);
+ const siblings = [];
+
+ while (sibling.node) {
+ siblings.push(sibling);
+ sibling = this.getSibling(++_key);
+ }
+
+ return siblings;
+}
+
+function getAllPrevSiblings() {
+ let _key = this.key;
+ let sibling = this.getSibling(--_key);
+ const siblings = [];
+
+ while (sibling.node) {
+ siblings.push(sibling);
+ sibling = this.getSibling(--_key);
+ }
+
+ return siblings;
+}
+
+function get(key, context = true) {
+ if (context === true) context = this.context;
+ const parts = key.split(".");
+
+ if (parts.length === 1) {
+ return this._getKey(key, context);
+ } else {
+ return this._getPattern(parts, context);
+ }
+}
+
+function _getKey(key, context) {
+ const node = this.node;
+ const container = node[key];
+
+ if (Array.isArray(container)) {
+ return container.map((_, i) => {
+ return _index.default.get({
+ listKey: key,
+ parentPath: this,
+ parent: node,
+ container: container,
+ key: i
+ }).setContext(context);
+ });
+ } else {
+ return _index.default.get({
+ parentPath: this,
+ parent: node,
+ container: node,
+ key: key
+ }).setContext(context);
+ }
+}
+
+function _getPattern(parts, context) {
+ let path = this;
+
+ for (const part of parts) {
+ if (part === ".") {
+ path = path.parentPath;
+ } else {
+ if (Array.isArray(path)) {
+ path = path[part];
+ } else {
+ path = path.get(part, context);
+ }
+ }
+ }
+
+ return path;
+}
+
+function getBindingIdentifiers(duplicates) {
+ return _getBindingIdentifiers(this.node, duplicates);
+}
+
+function getOuterBindingIdentifiers(duplicates) {
+ return _getOuterBindingIdentifiers(this.node, duplicates);
+}
+
+function getBindingIdentifierPaths(duplicates = false, outerOnly = false) {
+ const path = this;
+ const search = [path];
+ const ids = Object.create(null);
+
+ while (search.length) {
+ const id = search.shift();
+ if (!id) continue;
+ if (!id.node) continue;
+ const keys = _getBindingIdentifiers.keys[id.node.type];
+
+ if (id.isIdentifier()) {
+ if (duplicates) {
+ const _ids = ids[id.node.name] = ids[id.node.name] || [];
+
+ _ids.push(id);
+ } else {
+ ids[id.node.name] = id;
+ }
+
+ continue;
+ }
+
+ if (id.isExportDeclaration()) {
+ const declaration = id.get("declaration");
+
+ if (isDeclaration(declaration)) {
+ search.push(declaration);
+ }
+
+ continue;
+ }
+
+ if (outerOnly) {
+ if (id.isFunctionDeclaration()) {
+ search.push(id.get("id"));
+ continue;
+ }
+
+ if (id.isFunctionExpression()) {
+ continue;
+ }
+ }
+
+ if (keys) {
+ for (let i = 0; i < keys.length; i++) {
+ const key = keys[i];
+ const child = id.get(key);
+
+ if (Array.isArray(child)) {
+ search.push(...child);
+ } else if (child.node) {
+ search.push(child);
+ }
+ }
+ }
+ }
+
+ return ids;
+}
+
+function getOuterBindingIdentifierPaths(duplicates) {
+ return this.getBindingIdentifierPaths(duplicates, true);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/lib/path/generated/asserts.js b/node_modules/@babel/traverse/lib/path/generated/asserts.js
new file mode 100644
index 000000000..bee8a438e
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/path/generated/asserts.js
@@ -0,0 +1,5 @@
+"use strict";
+
+var t = require("@babel/types");
+
+var _index = require("../index");
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/lib/path/generated/validators.js b/node_modules/@babel/traverse/lib/path/generated/validators.js
new file mode 100644
index 000000000..bee8a438e
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/path/generated/validators.js
@@ -0,0 +1,5 @@
+"use strict";
+
+var t = require("@babel/types");
+
+var _index = require("../index");
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/lib/path/generated/virtual-types.js b/node_modules/@babel/traverse/lib/path/generated/virtual-types.js
new file mode 100644
index 000000000..bf37ed937
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/path/generated/virtual-types.js
@@ -0,0 +1,3 @@
+"use strict";
+
+var t = require("@babel/types");
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/lib/path/index.js b/node_modules/@babel/traverse/lib/path/index.js
new file mode 100644
index 000000000..93602608e
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/path/index.js
@@ -0,0 +1,257 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = exports.SHOULD_STOP = exports.SHOULD_SKIP = exports.REMOVED = void 0;
+
+var virtualTypes = require("./lib/virtual-types");
+
+var _debug = require("debug");
+
+var _index = require("../index");
+
+var _scope = require("../scope");
+
+var _t = require("@babel/types");
+
+var t = _t;
+
+var _cache = require("../cache");
+
+var _generator = require("@babel/generator");
+
+var NodePath_ancestry = require("./ancestry");
+
+var NodePath_inference = require("./inference");
+
+var NodePath_replacement = require("./replacement");
+
+var NodePath_evaluation = require("./evaluation");
+
+var NodePath_conversion = require("./conversion");
+
+var NodePath_introspection = require("./introspection");
+
+var NodePath_context = require("./context");
+
+var NodePath_removal = require("./removal");
+
+var NodePath_modification = require("./modification");
+
+var NodePath_family = require("./family");
+
+var NodePath_comments = require("./comments");
+
+const {
+ validate
+} = _t;
+
+const debug = _debug("babel");
+
+const REMOVED = 1 << 0;
+exports.REMOVED = REMOVED;
+const SHOULD_STOP = 1 << 1;
+exports.SHOULD_STOP = SHOULD_STOP;
+const SHOULD_SKIP = 1 << 2;
+exports.SHOULD_SKIP = SHOULD_SKIP;
+
+class NodePath {
+ constructor(hub, parent) {
+ this.contexts = [];
+ this.state = null;
+ this.opts = null;
+ this._traverseFlags = 0;
+ this.skipKeys = null;
+ this.parentPath = null;
+ this.container = null;
+ this.listKey = null;
+ this.key = null;
+ this.node = null;
+ this.type = null;
+ this.parent = parent;
+ this.hub = hub;
+ this.data = null;
+ this.context = null;
+ this.scope = null;
+ }
+
+ static get({
+ hub,
+ parentPath,
+ parent,
+ container,
+ listKey,
+ key
+ }) {
+ if (!hub && parentPath) {
+ hub = parentPath.hub;
+ }
+
+ if (!parent) {
+ throw new Error("To get a node path the parent needs to exist");
+ }
+
+ const targetNode = container[key];
+
+ let paths = _cache.path.get(parent);
+
+ if (!paths) {
+ paths = new Map();
+
+ _cache.path.set(parent, paths);
+ }
+
+ let path = paths.get(targetNode);
+
+ if (!path) {
+ path = new NodePath(hub, parent);
+ if (targetNode) paths.set(targetNode, path);
+ }
+
+ path.setup(parentPath, container, listKey, key);
+ return path;
+ }
+
+ getScope(scope) {
+ return this.isScope() ? new _scope.default(this) : scope;
+ }
+
+ setData(key, val) {
+ if (this.data == null) {
+ this.data = Object.create(null);
+ }
+
+ return this.data[key] = val;
+ }
+
+ getData(key, def) {
+ if (this.data == null) {
+ this.data = Object.create(null);
+ }
+
+ let val = this.data[key];
+ if (val === undefined && def !== undefined) val = this.data[key] = def;
+ return val;
+ }
+
+ hasNode() {
+ return this.node != null;
+ }
+
+ buildCodeFrameError(msg, Error = SyntaxError) {
+ return this.hub.buildError(this.node, msg, Error);
+ }
+
+ traverse(visitor, state) {
+ (0, _index.default)(this.node, visitor, this.scope, state, this);
+ }
+
+ set(key, node) {
+ validate(this.node, key, node);
+ this.node[key] = node;
+ }
+
+ getPathLocation() {
+ const parts = [];
+ let path = this;
+
+ do {
+ let key = path.key;
+ if (path.inList) key = `${path.listKey}[${key}]`;
+ parts.unshift(key);
+ } while (path = path.parentPath);
+
+ return parts.join(".");
+ }
+
+ debug(message) {
+ if (!debug.enabled) return;
+ debug(`${this.getPathLocation()} ${this.type}: ${message}`);
+ }
+
+ toString() {
+ return (0, _generator.default)(this.node).code;
+ }
+
+ get inList() {
+ return !!this.listKey;
+ }
+
+ set inList(inList) {
+ if (!inList) {
+ this.listKey = null;
+ }
+ }
+
+ get parentKey() {
+ return this.listKey || this.key;
+ }
+
+ get shouldSkip() {
+ return !!(this._traverseFlags & SHOULD_SKIP);
+ }
+
+ set shouldSkip(v) {
+ if (v) {
+ this._traverseFlags |= SHOULD_SKIP;
+ } else {
+ this._traverseFlags &= ~SHOULD_SKIP;
+ }
+ }
+
+ get shouldStop() {
+ return !!(this._traverseFlags & SHOULD_STOP);
+ }
+
+ set shouldStop(v) {
+ if (v) {
+ this._traverseFlags |= SHOULD_STOP;
+ } else {
+ this._traverseFlags &= ~SHOULD_STOP;
+ }
+ }
+
+ get removed() {
+ return !!(this._traverseFlags & REMOVED);
+ }
+
+ set removed(v) {
+ if (v) {
+ this._traverseFlags |= REMOVED;
+ } else {
+ this._traverseFlags &= ~REMOVED;
+ }
+ }
+
+}
+
+Object.assign(NodePath.prototype, NodePath_ancestry, NodePath_inference, NodePath_replacement, NodePath_evaluation, NodePath_conversion, NodePath_introspection, NodePath_context, NodePath_removal, NodePath_modification, NodePath_family, NodePath_comments);
+
+for (const type of t.TYPES) {
+ const typeKey = `is${type}`;
+ const fn = t[typeKey];
+
+ NodePath.prototype[typeKey] = function (opts) {
+ return fn(this.node, opts);
+ };
+
+ NodePath.prototype[`assert${type}`] = function (opts) {
+ if (!fn(this.node, opts)) {
+ throw new TypeError(`Expected node path of type ${type}`);
+ }
+ };
+}
+
+for (const type of Object.keys(virtualTypes)) {
+ if (type[0] === "_") continue;
+ if (t.TYPES.indexOf(type) < 0) t.TYPES.push(type);
+ const virtualType = virtualTypes[type];
+
+ NodePath.prototype[`is${type}`] = function (opts) {
+ return virtualType.checkPath(this, opts);
+ };
+}
+
+var _default = NodePath;
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/lib/path/inference/index.js b/node_modules/@babel/traverse/lib/path/inference/index.js
new file mode 100644
index 000000000..f7fef255a
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/path/inference/index.js
@@ -0,0 +1,156 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports._getTypeAnnotation = _getTypeAnnotation;
+exports.baseTypeStrictlyMatches = baseTypeStrictlyMatches;
+exports.couldBeBaseType = couldBeBaseType;
+exports.getTypeAnnotation = getTypeAnnotation;
+exports.isBaseType = isBaseType;
+exports.isGenericType = isGenericType;
+
+var inferers = require("./inferers");
+
+var _t = require("@babel/types");
+
+const {
+ anyTypeAnnotation,
+ isAnyTypeAnnotation,
+ isBooleanTypeAnnotation,
+ isEmptyTypeAnnotation,
+ isFlowBaseAnnotation,
+ isGenericTypeAnnotation,
+ isIdentifier,
+ isMixedTypeAnnotation,
+ isNumberTypeAnnotation,
+ isStringTypeAnnotation,
+ isTypeAnnotation,
+ isUnionTypeAnnotation,
+ isVoidTypeAnnotation,
+ stringTypeAnnotation,
+ voidTypeAnnotation
+} = _t;
+
+function getTypeAnnotation() {
+ if (this.typeAnnotation) return this.typeAnnotation;
+ let type = this._getTypeAnnotation() || anyTypeAnnotation();
+ if (isTypeAnnotation(type)) type = type.typeAnnotation;
+ return this.typeAnnotation = type;
+}
+
+const typeAnnotationInferringNodes = new WeakSet();
+
+function _getTypeAnnotation() {
+ const node = this.node;
+
+ if (!node) {
+ if (this.key === "init" && this.parentPath.isVariableDeclarator()) {
+ const declar = this.parentPath.parentPath;
+ const declarParent = declar.parentPath;
+
+ if (declar.key === "left" && declarParent.isForInStatement()) {
+ return stringTypeAnnotation();
+ }
+
+ if (declar.key === "left" && declarParent.isForOfStatement()) {
+ return anyTypeAnnotation();
+ }
+
+ return voidTypeAnnotation();
+ } else {
+ return;
+ }
+ }
+
+ if (node.typeAnnotation) {
+ return node.typeAnnotation;
+ }
+
+ if (typeAnnotationInferringNodes.has(node)) {
+ return;
+ }
+
+ typeAnnotationInferringNodes.add(node);
+
+ try {
+ var _inferer;
+
+ let inferer = inferers[node.type];
+
+ if (inferer) {
+ return inferer.call(this, node);
+ }
+
+ inferer = inferers[this.parentPath.type];
+
+ if ((_inferer = inferer) != null && _inferer.validParent) {
+ return this.parentPath.getTypeAnnotation();
+ }
+ } finally {
+ typeAnnotationInferringNodes.delete(node);
+ }
+}
+
+function isBaseType(baseName, soft) {
+ return _isBaseType(baseName, this.getTypeAnnotation(), soft);
+}
+
+function _isBaseType(baseName, type, soft) {
+ if (baseName === "string") {
+ return isStringTypeAnnotation(type);
+ } else if (baseName === "number") {
+ return isNumberTypeAnnotation(type);
+ } else if (baseName === "boolean") {
+ return isBooleanTypeAnnotation(type);
+ } else if (baseName === "any") {
+ return isAnyTypeAnnotation(type);
+ } else if (baseName === "mixed") {
+ return isMixedTypeAnnotation(type);
+ } else if (baseName === "empty") {
+ return isEmptyTypeAnnotation(type);
+ } else if (baseName === "void") {
+ return isVoidTypeAnnotation(type);
+ } else {
+ if (soft) {
+ return false;
+ } else {
+ throw new Error(`Unknown base type ${baseName}`);
+ }
+ }
+}
+
+function couldBeBaseType(name) {
+ const type = this.getTypeAnnotation();
+ if (isAnyTypeAnnotation(type)) return true;
+
+ if (isUnionTypeAnnotation(type)) {
+ for (const type2 of type.types) {
+ if (isAnyTypeAnnotation(type2) || _isBaseType(name, type2, true)) {
+ return true;
+ }
+ }
+
+ return false;
+ } else {
+ return _isBaseType(name, type, true);
+ }
+}
+
+function baseTypeStrictlyMatches(rightArg) {
+ const left = this.getTypeAnnotation();
+ const right = rightArg.getTypeAnnotation();
+
+ if (!isAnyTypeAnnotation(left) && isFlowBaseAnnotation(left)) {
+ return right.type === left.type;
+ }
+
+ return false;
+}
+
+function isGenericType(genericName) {
+ const type = this.getTypeAnnotation();
+ return isGenericTypeAnnotation(type) && isIdentifier(type.id, {
+ name: genericName
+ });
+}
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/lib/path/inference/inferer-reference.js b/node_modules/@babel/traverse/lib/path/inference/inferer-reference.js
new file mode 100644
index 000000000..c328dc150
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/path/inference/inferer-reference.js
@@ -0,0 +1,206 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = _default;
+
+var _t = require("@babel/types");
+
+const {
+ BOOLEAN_NUMBER_BINARY_OPERATORS,
+ createFlowUnionType,
+ createTSUnionType,
+ createTypeAnnotationBasedOnTypeof,
+ createUnionTypeAnnotation,
+ isTSTypeAnnotation,
+ numberTypeAnnotation,
+ voidTypeAnnotation
+} = _t;
+
+function _default(node) {
+ if (!this.isReferenced()) return;
+ const binding = this.scope.getBinding(node.name);
+
+ if (binding) {
+ if (binding.identifier.typeAnnotation) {
+ return binding.identifier.typeAnnotation;
+ } else {
+ return getTypeAnnotationBindingConstantViolations(binding, this, node.name);
+ }
+ }
+
+ if (node.name === "undefined") {
+ return voidTypeAnnotation();
+ } else if (node.name === "NaN" || node.name === "Infinity") {
+ return numberTypeAnnotation();
+ } else if (node.name === "arguments") {}
+}
+
+function getTypeAnnotationBindingConstantViolations(binding, path, name) {
+ const types = [];
+ const functionConstantViolations = [];
+ let constantViolations = getConstantViolationsBefore(binding, path, functionConstantViolations);
+ const testType = getConditionalAnnotation(binding, path, name);
+
+ if (testType) {
+ const testConstantViolations = getConstantViolationsBefore(binding, testType.ifStatement);
+ constantViolations = constantViolations.filter(path => testConstantViolations.indexOf(path) < 0);
+ types.push(testType.typeAnnotation);
+ }
+
+ if (constantViolations.length) {
+ constantViolations.push(...functionConstantViolations);
+
+ for (const violation of constantViolations) {
+ types.push(violation.getTypeAnnotation());
+ }
+ }
+
+ if (!types.length) {
+ return;
+ }
+
+ if (isTSTypeAnnotation(types[0]) && createTSUnionType) {
+ return createTSUnionType(types);
+ }
+
+ if (createFlowUnionType) {
+ return createFlowUnionType(types);
+ }
+
+ return createUnionTypeAnnotation(types);
+}
+
+function getConstantViolationsBefore(binding, path, functions) {
+ const violations = binding.constantViolations.slice();
+ violations.unshift(binding.path);
+ return violations.filter(violation => {
+ violation = violation.resolve();
+
+ const status = violation._guessExecutionStatusRelativeTo(path);
+
+ if (functions && status === "unknown") functions.push(violation);
+ return status === "before";
+ });
+}
+
+function inferAnnotationFromBinaryExpression(name, path) {
+ const operator = path.node.operator;
+ const right = path.get("right").resolve();
+ const left = path.get("left").resolve();
+ let target;
+
+ if (left.isIdentifier({
+ name
+ })) {
+ target = right;
+ } else if (right.isIdentifier({
+ name
+ })) {
+ target = left;
+ }
+
+ if (target) {
+ if (operator === "===") {
+ return target.getTypeAnnotation();
+ }
+
+ if (BOOLEAN_NUMBER_BINARY_OPERATORS.indexOf(operator) >= 0) {
+ return numberTypeAnnotation();
+ }
+
+ return;
+ }
+
+ if (operator !== "===" && operator !== "==") return;
+ let typeofPath;
+ let typePath;
+
+ if (left.isUnaryExpression({
+ operator: "typeof"
+ })) {
+ typeofPath = left;
+ typePath = right;
+ } else if (right.isUnaryExpression({
+ operator: "typeof"
+ })) {
+ typeofPath = right;
+ typePath = left;
+ }
+
+ if (!typeofPath) return;
+ if (!typeofPath.get("argument").isIdentifier({
+ name
+ })) return;
+ typePath = typePath.resolve();
+ if (!typePath.isLiteral()) return;
+ const typeValue = typePath.node.value;
+ if (typeof typeValue !== "string") return;
+ return createTypeAnnotationBasedOnTypeof(typeValue);
+}
+
+function getParentConditionalPath(binding, path, name) {
+ let parentPath;
+
+ while (parentPath = path.parentPath) {
+ if (parentPath.isIfStatement() || parentPath.isConditionalExpression()) {
+ if (path.key === "test") {
+ return;
+ }
+
+ return parentPath;
+ }
+
+ if (parentPath.isFunction()) {
+ if (parentPath.parentPath.scope.getBinding(name) !== binding) return;
+ }
+
+ path = parentPath;
+ }
+}
+
+function getConditionalAnnotation(binding, path, name) {
+ const ifStatement = getParentConditionalPath(binding, path, name);
+ if (!ifStatement) return;
+ const test = ifStatement.get("test");
+ const paths = [test];
+ const types = [];
+
+ for (let i = 0; i < paths.length; i++) {
+ const path = paths[i];
+
+ if (path.isLogicalExpression()) {
+ if (path.node.operator === "&&") {
+ paths.push(path.get("left"));
+ paths.push(path.get("right"));
+ }
+ } else if (path.isBinaryExpression()) {
+ const type = inferAnnotationFromBinaryExpression(name, path);
+ if (type) types.push(type);
+ }
+ }
+
+ if (types.length) {
+ if (isTSTypeAnnotation(types[0]) && createTSUnionType) {
+ return {
+ typeAnnotation: createTSUnionType(types),
+ ifStatement
+ };
+ }
+
+ if (createFlowUnionType) {
+ return {
+ typeAnnotation: createFlowUnionType(types),
+ ifStatement
+ };
+ }
+
+ return {
+ typeAnnotation: createUnionTypeAnnotation(types),
+ ifStatement
+ };
+ }
+
+ return getConditionalAnnotation(ifStatement, name);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/lib/path/inference/inferers.js b/node_modules/@babel/traverse/lib/path/inference/inferers.js
new file mode 100644
index 000000000..68180ac54
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/path/inference/inferers.js
@@ -0,0 +1,261 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.ArrayExpression = ArrayExpression;
+exports.AssignmentExpression = AssignmentExpression;
+exports.BinaryExpression = BinaryExpression;
+exports.BooleanLiteral = BooleanLiteral;
+exports.CallExpression = CallExpression;
+exports.ConditionalExpression = ConditionalExpression;
+exports.ClassDeclaration = exports.ClassExpression = exports.FunctionDeclaration = exports.ArrowFunctionExpression = exports.FunctionExpression = Func;
+Object.defineProperty(exports, "Identifier", {
+ enumerable: true,
+ get: function () {
+ return _infererReference.default;
+ }
+});
+exports.LogicalExpression = LogicalExpression;
+exports.NewExpression = NewExpression;
+exports.NullLiteral = NullLiteral;
+exports.NumericLiteral = NumericLiteral;
+exports.ObjectExpression = ObjectExpression;
+exports.ParenthesizedExpression = ParenthesizedExpression;
+exports.RegExpLiteral = RegExpLiteral;
+exports.RestElement = RestElement;
+exports.SequenceExpression = SequenceExpression;
+exports.StringLiteral = StringLiteral;
+exports.TaggedTemplateExpression = TaggedTemplateExpression;
+exports.TemplateLiteral = TemplateLiteral;
+exports.TypeCastExpression = TypeCastExpression;
+exports.UnaryExpression = UnaryExpression;
+exports.UpdateExpression = UpdateExpression;
+exports.VariableDeclarator = VariableDeclarator;
+
+var _t = require("@babel/types");
+
+var _infererReference = require("./inferer-reference");
+
+const {
+ BOOLEAN_BINARY_OPERATORS,
+ BOOLEAN_UNARY_OPERATORS,
+ NUMBER_BINARY_OPERATORS,
+ NUMBER_UNARY_OPERATORS,
+ STRING_UNARY_OPERATORS,
+ anyTypeAnnotation,
+ arrayTypeAnnotation,
+ booleanTypeAnnotation,
+ buildMatchMemberExpression,
+ createFlowUnionType,
+ createTSUnionType,
+ createUnionTypeAnnotation,
+ genericTypeAnnotation,
+ identifier,
+ isTSTypeAnnotation,
+ nullLiteralTypeAnnotation,
+ numberTypeAnnotation,
+ stringTypeAnnotation,
+ tupleTypeAnnotation,
+ unionTypeAnnotation,
+ voidTypeAnnotation
+} = _t;
+
+function VariableDeclarator() {
+ var _type;
+
+ const id = this.get("id");
+ if (!id.isIdentifier()) return;
+ const init = this.get("init");
+ let type = init.getTypeAnnotation();
+
+ if (((_type = type) == null ? void 0 : _type.type) === "AnyTypeAnnotation") {
+ if (init.isCallExpression() && init.get("callee").isIdentifier({
+ name: "Array"
+ }) && !init.scope.hasBinding("Array", true)) {
+ type = ArrayExpression();
+ }
+ }
+
+ return type;
+}
+
+function TypeCastExpression(node) {
+ return node.typeAnnotation;
+}
+
+TypeCastExpression.validParent = true;
+
+function NewExpression(node) {
+ if (this.get("callee").isIdentifier()) {
+ return genericTypeAnnotation(node.callee);
+ }
+}
+
+function TemplateLiteral() {
+ return stringTypeAnnotation();
+}
+
+function UnaryExpression(node) {
+ const operator = node.operator;
+
+ if (operator === "void") {
+ return voidTypeAnnotation();
+ } else if (NUMBER_UNARY_OPERATORS.indexOf(operator) >= 0) {
+ return numberTypeAnnotation();
+ } else if (STRING_UNARY_OPERATORS.indexOf(operator) >= 0) {
+ return stringTypeAnnotation();
+ } else if (BOOLEAN_UNARY_OPERATORS.indexOf(operator) >= 0) {
+ return booleanTypeAnnotation();
+ }
+}
+
+function BinaryExpression(node) {
+ const operator = node.operator;
+
+ if (NUMBER_BINARY_OPERATORS.indexOf(operator) >= 0) {
+ return numberTypeAnnotation();
+ } else if (BOOLEAN_BINARY_OPERATORS.indexOf(operator) >= 0) {
+ return booleanTypeAnnotation();
+ } else if (operator === "+") {
+ const right = this.get("right");
+ const left = this.get("left");
+
+ if (left.isBaseType("number") && right.isBaseType("number")) {
+ return numberTypeAnnotation();
+ } else if (left.isBaseType("string") || right.isBaseType("string")) {
+ return stringTypeAnnotation();
+ }
+
+ return unionTypeAnnotation([stringTypeAnnotation(), numberTypeAnnotation()]);
+ }
+}
+
+function LogicalExpression() {
+ const argumentTypes = [this.get("left").getTypeAnnotation(), this.get("right").getTypeAnnotation()];
+
+ if (isTSTypeAnnotation(argumentTypes[0]) && createTSUnionType) {
+ return createTSUnionType(argumentTypes);
+ }
+
+ if (createFlowUnionType) {
+ return createFlowUnionType(argumentTypes);
+ }
+
+ return createUnionTypeAnnotation(argumentTypes);
+}
+
+function ConditionalExpression() {
+ const argumentTypes = [this.get("consequent").getTypeAnnotation(), this.get("alternate").getTypeAnnotation()];
+
+ if (isTSTypeAnnotation(argumentTypes[0]) && createTSUnionType) {
+ return createTSUnionType(argumentTypes);
+ }
+
+ if (createFlowUnionType) {
+ return createFlowUnionType(argumentTypes);
+ }
+
+ return createUnionTypeAnnotation(argumentTypes);
+}
+
+function SequenceExpression() {
+ return this.get("expressions").pop().getTypeAnnotation();
+}
+
+function ParenthesizedExpression() {
+ return this.get("expression").getTypeAnnotation();
+}
+
+function AssignmentExpression() {
+ return this.get("right").getTypeAnnotation();
+}
+
+function UpdateExpression(node) {
+ const operator = node.operator;
+
+ if (operator === "++" || operator === "--") {
+ return numberTypeAnnotation();
+ }
+}
+
+function StringLiteral() {
+ return stringTypeAnnotation();
+}
+
+function NumericLiteral() {
+ return numberTypeAnnotation();
+}
+
+function BooleanLiteral() {
+ return booleanTypeAnnotation();
+}
+
+function NullLiteral() {
+ return nullLiteralTypeAnnotation();
+}
+
+function RegExpLiteral() {
+ return genericTypeAnnotation(identifier("RegExp"));
+}
+
+function ObjectExpression() {
+ return genericTypeAnnotation(identifier("Object"));
+}
+
+function ArrayExpression() {
+ return genericTypeAnnotation(identifier("Array"));
+}
+
+function RestElement() {
+ return ArrayExpression();
+}
+
+RestElement.validParent = true;
+
+function Func() {
+ return genericTypeAnnotation(identifier("Function"));
+}
+
+const isArrayFrom = buildMatchMemberExpression("Array.from");
+const isObjectKeys = buildMatchMemberExpression("Object.keys");
+const isObjectValues = buildMatchMemberExpression("Object.values");
+const isObjectEntries = buildMatchMemberExpression("Object.entries");
+
+function CallExpression() {
+ const {
+ callee
+ } = this.node;
+
+ if (isObjectKeys(callee)) {
+ return arrayTypeAnnotation(stringTypeAnnotation());
+ } else if (isArrayFrom(callee) || isObjectValues(callee)) {
+ return arrayTypeAnnotation(anyTypeAnnotation());
+ } else if (isObjectEntries(callee)) {
+ return arrayTypeAnnotation(tupleTypeAnnotation([stringTypeAnnotation(), anyTypeAnnotation()]));
+ }
+
+ return resolveCall(this.get("callee"));
+}
+
+function TaggedTemplateExpression() {
+ return resolveCall(this.get("tag"));
+}
+
+function resolveCall(callee) {
+ callee = callee.resolve();
+
+ if (callee.isFunction()) {
+ if (callee.is("async")) {
+ if (callee.is("generator")) {
+ return genericTypeAnnotation(identifier("AsyncIterator"));
+ } else {
+ return genericTypeAnnotation(identifier("Promise"));
+ }
+ } else {
+ if (callee.node.returnType) {
+ return callee.node.returnType;
+ } else {}
+ }
+ }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/lib/path/introspection.js b/node_modules/@babel/traverse/lib/path/introspection.js
new file mode 100644
index 000000000..48d6ef1e1
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/path/introspection.js
@@ -0,0 +1,436 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports._guessExecutionStatusRelativeTo = _guessExecutionStatusRelativeTo;
+exports._guessExecutionStatusRelativeToDifferentFunctions = _guessExecutionStatusRelativeToDifferentFunctions;
+exports._resolve = _resolve;
+exports.canHaveVariableDeclarationOrExpression = canHaveVariableDeclarationOrExpression;
+exports.canSwapBetweenExpressionAndStatement = canSwapBetweenExpressionAndStatement;
+exports.equals = equals;
+exports.getSource = getSource;
+exports.has = has;
+exports.is = void 0;
+exports.isCompletionRecord = isCompletionRecord;
+exports.isConstantExpression = isConstantExpression;
+exports.isInStrictMode = isInStrictMode;
+exports.isNodeType = isNodeType;
+exports.isStatementOrBlock = isStatementOrBlock;
+exports.isStatic = isStatic;
+exports.isnt = isnt;
+exports.matchesPattern = matchesPattern;
+exports.referencesImport = referencesImport;
+exports.resolve = resolve;
+exports.willIMaybeExecuteBefore = willIMaybeExecuteBefore;
+
+var _t = require("@babel/types");
+
+const {
+ STATEMENT_OR_BLOCK_KEYS,
+ VISITOR_KEYS,
+ isBlockStatement,
+ isExpression,
+ isIdentifier,
+ isLiteral,
+ isStringLiteral,
+ isType,
+ matchesPattern: _matchesPattern
+} = _t;
+
+function matchesPattern(pattern, allowPartial) {
+ return _matchesPattern(this.node, pattern, allowPartial);
+}
+
+function has(key) {
+ const val = this.node && this.node[key];
+
+ if (val && Array.isArray(val)) {
+ return !!val.length;
+ } else {
+ return !!val;
+ }
+}
+
+function isStatic() {
+ return this.scope.isStatic(this.node);
+}
+
+const is = has;
+exports.is = is;
+
+function isnt(key) {
+ return !this.has(key);
+}
+
+function equals(key, value) {
+ return this.node[key] === value;
+}
+
+function isNodeType(type) {
+ return isType(this.type, type);
+}
+
+function canHaveVariableDeclarationOrExpression() {
+ return (this.key === "init" || this.key === "left") && this.parentPath.isFor();
+}
+
+function canSwapBetweenExpressionAndStatement(replacement) {
+ if (this.key !== "body" || !this.parentPath.isArrowFunctionExpression()) {
+ return false;
+ }
+
+ if (this.isExpression()) {
+ return isBlockStatement(replacement);
+ } else if (this.isBlockStatement()) {
+ return isExpression(replacement);
+ }
+
+ return false;
+}
+
+function isCompletionRecord(allowInsideFunction) {
+ let path = this;
+ let first = true;
+
+ do {
+ const container = path.container;
+
+ if (path.isFunction() && !first) {
+ return !!allowInsideFunction;
+ }
+
+ first = false;
+
+ if (Array.isArray(container) && path.key !== container.length - 1) {
+ return false;
+ }
+ } while ((path = path.parentPath) && !path.isProgram());
+
+ return true;
+}
+
+function isStatementOrBlock() {
+ if (this.parentPath.isLabeledStatement() || isBlockStatement(this.container)) {
+ return false;
+ } else {
+ return STATEMENT_OR_BLOCK_KEYS.includes(this.key);
+ }
+}
+
+function referencesImport(moduleSource, importName) {
+ if (!this.isReferencedIdentifier()) {
+ if ((this.isMemberExpression() || this.isOptionalMemberExpression()) && (this.node.computed ? isStringLiteral(this.node.property, {
+ value: importName
+ }) : this.node.property.name === importName)) {
+ const object = this.get("object");
+ return object.isReferencedIdentifier() && object.referencesImport(moduleSource, "*");
+ }
+
+ return false;
+ }
+
+ const binding = this.scope.getBinding(this.node.name);
+ if (!binding || binding.kind !== "module") return false;
+ const path = binding.path;
+ const parent = path.parentPath;
+ if (!parent.isImportDeclaration()) return false;
+
+ if (parent.node.source.value === moduleSource) {
+ if (!importName) return true;
+ } else {
+ return false;
+ }
+
+ if (path.isImportDefaultSpecifier() && importName === "default") {
+ return true;
+ }
+
+ if (path.isImportNamespaceSpecifier() && importName === "*") {
+ return true;
+ }
+
+ if (path.isImportSpecifier() && isIdentifier(path.node.imported, {
+ name: importName
+ })) {
+ return true;
+ }
+
+ return false;
+}
+
+function getSource() {
+ const node = this.node;
+
+ if (node.end) {
+ const code = this.hub.getCode();
+ if (code) return code.slice(node.start, node.end);
+ }
+
+ return "";
+}
+
+function willIMaybeExecuteBefore(target) {
+ return this._guessExecutionStatusRelativeTo(target) !== "after";
+}
+
+function getOuterFunction(path) {
+ return (path.scope.getFunctionParent() || path.scope.getProgramParent()).path;
+}
+
+function isExecutionUncertain(type, key) {
+ switch (type) {
+ case "LogicalExpression":
+ return key === "right";
+
+ case "ConditionalExpression":
+ case "IfStatement":
+ return key === "consequent" || key === "alternate";
+
+ case "WhileStatement":
+ case "DoWhileStatement":
+ case "ForInStatement":
+ case "ForOfStatement":
+ return key === "body";
+
+ case "ForStatement":
+ return key === "body" || key === "update";
+
+ case "SwitchStatement":
+ return key === "cases";
+
+ case "TryStatement":
+ return key === "handler";
+
+ case "AssignmentPattern":
+ return key === "right";
+
+ case "OptionalMemberExpression":
+ return key === "property";
+
+ case "OptionalCallExpression":
+ return key === "arguments";
+
+ default:
+ return false;
+ }
+}
+
+function isExecutionUncertainInList(paths, maxIndex) {
+ for (let i = 0; i < maxIndex; i++) {
+ const path = paths[i];
+
+ if (isExecutionUncertain(path.parent.type, path.parentKey)) {
+ return true;
+ }
+ }
+
+ return false;
+}
+
+function _guessExecutionStatusRelativeTo(target) {
+ const funcParent = {
+ this: getOuterFunction(this),
+ target: getOuterFunction(target)
+ };
+
+ if (funcParent.target.node !== funcParent.this.node) {
+ return this._guessExecutionStatusRelativeToDifferentFunctions(funcParent.target);
+ }
+
+ const paths = {
+ target: target.getAncestry(),
+ this: this.getAncestry()
+ };
+ if (paths.target.indexOf(this) >= 0) return "after";
+ if (paths.this.indexOf(target) >= 0) return "before";
+ let commonPath;
+ const commonIndex = {
+ target: 0,
+ this: 0
+ };
+
+ while (!commonPath && commonIndex.this < paths.this.length) {
+ const path = paths.this[commonIndex.this];
+ commonIndex.target = paths.target.indexOf(path);
+
+ if (commonIndex.target >= 0) {
+ commonPath = path;
+ } else {
+ commonIndex.this++;
+ }
+ }
+
+ if (!commonPath) {
+ throw new Error("Internal Babel error - The two compared nodes" + " don't appear to belong to the same program.");
+ }
+
+ if (isExecutionUncertainInList(paths.this, commonIndex.this - 1) || isExecutionUncertainInList(paths.target, commonIndex.target - 1)) {
+ return "unknown";
+ }
+
+ const divergence = {
+ this: paths.this[commonIndex.this - 1],
+ target: paths.target[commonIndex.target - 1]
+ };
+
+ if (divergence.target.listKey && divergence.this.listKey && divergence.target.container === divergence.this.container) {
+ return divergence.target.key > divergence.this.key ? "before" : "after";
+ }
+
+ const keys = VISITOR_KEYS[commonPath.type];
+ const keyPosition = {
+ this: keys.indexOf(divergence.this.parentKey),
+ target: keys.indexOf(divergence.target.parentKey)
+ };
+ return keyPosition.target > keyPosition.this ? "before" : "after";
+}
+
+const executionOrderCheckedNodes = new WeakSet();
+
+function _guessExecutionStatusRelativeToDifferentFunctions(target) {
+ if (!target.isFunctionDeclaration() || target.parentPath.isExportDeclaration()) {
+ return "unknown";
+ }
+
+ const binding = target.scope.getBinding(target.node.id.name);
+ if (!binding.references) return "before";
+ const referencePaths = binding.referencePaths;
+ let allStatus;
+
+ for (const path of referencePaths) {
+ const childOfFunction = !!path.find(path => path.node === target.node);
+ if (childOfFunction) continue;
+
+ if (path.key !== "callee" || !path.parentPath.isCallExpression()) {
+ return "unknown";
+ }
+
+ if (executionOrderCheckedNodes.has(path.node)) continue;
+ executionOrderCheckedNodes.add(path.node);
+
+ const status = this._guessExecutionStatusRelativeTo(path);
+
+ executionOrderCheckedNodes.delete(path.node);
+
+ if (allStatus && allStatus !== status) {
+ return "unknown";
+ } else {
+ allStatus = status;
+ }
+ }
+
+ return allStatus;
+}
+
+function resolve(dangerous, resolved) {
+ return this._resolve(dangerous, resolved) || this;
+}
+
+function _resolve(dangerous, resolved) {
+ if (resolved && resolved.indexOf(this) >= 0) return;
+ resolved = resolved || [];
+ resolved.push(this);
+
+ if (this.isVariableDeclarator()) {
+ if (this.get("id").isIdentifier()) {
+ return this.get("init").resolve(dangerous, resolved);
+ } else {}
+ } else if (this.isReferencedIdentifier()) {
+ const binding = this.scope.getBinding(this.node.name);
+ if (!binding) return;
+ if (!binding.constant) return;
+ if (binding.kind === "module") return;
+
+ if (binding.path !== this) {
+ const ret = binding.path.resolve(dangerous, resolved);
+ if (this.find(parent => parent.node === ret.node)) return;
+ return ret;
+ }
+ } else if (this.isTypeCastExpression()) {
+ return this.get("expression").resolve(dangerous, resolved);
+ } else if (dangerous && this.isMemberExpression()) {
+ const targetKey = this.toComputedKey();
+ if (!isLiteral(targetKey)) return;
+ const targetName = targetKey.value;
+ const target = this.get("object").resolve(dangerous, resolved);
+
+ if (target.isObjectExpression()) {
+ const props = target.get("properties");
+
+ for (const prop of props) {
+ if (!prop.isProperty()) continue;
+ const key = prop.get("key");
+ let match = prop.isnt("computed") && key.isIdentifier({
+ name: targetName
+ });
+ match = match || key.isLiteral({
+ value: targetName
+ });
+ if (match) return prop.get("value").resolve(dangerous, resolved);
+ }
+ } else if (target.isArrayExpression() && !isNaN(+targetName)) {
+ const elems = target.get("elements");
+ const elem = elems[targetName];
+ if (elem) return elem.resolve(dangerous, resolved);
+ }
+ }
+}
+
+function isConstantExpression() {
+ if (this.isIdentifier()) {
+ const binding = this.scope.getBinding(this.node.name);
+ if (!binding) return false;
+ return binding.constant;
+ }
+
+ if (this.isLiteral()) {
+ if (this.isRegExpLiteral()) {
+ return false;
+ }
+
+ if (this.isTemplateLiteral()) {
+ return this.get("expressions").every(expression => expression.isConstantExpression());
+ }
+
+ return true;
+ }
+
+ if (this.isUnaryExpression()) {
+ if (this.node.operator !== "void") {
+ return false;
+ }
+
+ return this.get("argument").isConstantExpression();
+ }
+
+ if (this.isBinaryExpression()) {
+ return this.get("left").isConstantExpression() && this.get("right").isConstantExpression();
+ }
+
+ return false;
+}
+
+function isInStrictMode() {
+ const start = this.isProgram() ? this : this.parentPath;
+ const strictParent = start.find(path => {
+ if (path.isProgram({
+ sourceType: "module"
+ })) return true;
+ if (path.isClass()) return true;
+ if (!path.isProgram() && !path.isFunction()) return false;
+
+ if (path.isArrowFunctionExpression() && !path.get("body").isBlockStatement()) {
+ return false;
+ }
+
+ const body = path.isFunction() ? path.node.body : path.node;
+
+ for (const directive of body.directives) {
+ if (directive.value.value === "use strict") {
+ return true;
+ }
+ }
+ });
+ return !!strictParent;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/lib/path/lib/hoister.js b/node_modules/@babel/traverse/lib/path/lib/hoister.js
new file mode 100644
index 000000000..536a34097
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/path/lib/hoister.js
@@ -0,0 +1,206 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = void 0;
+
+var _t = require("@babel/types");
+
+var _t2 = _t;
+const {
+ react
+} = _t;
+const {
+ cloneNode,
+ jsxExpressionContainer,
+ variableDeclaration,
+ variableDeclarator
+} = _t2;
+const referenceVisitor = {
+ ReferencedIdentifier(path, state) {
+ if (path.isJSXIdentifier() && react.isCompatTag(path.node.name) && !path.parentPath.isJSXMemberExpression()) {
+ return;
+ }
+
+ if (path.node.name === "this") {
+ let scope = path.scope;
+
+ do {
+ if (scope.path.isFunction() && !scope.path.isArrowFunctionExpression()) {
+ break;
+ }
+ } while (scope = scope.parent);
+
+ if (scope) state.breakOnScopePaths.push(scope.path);
+ }
+
+ const binding = path.scope.getBinding(path.node.name);
+ if (!binding) return;
+
+ for (const violation of binding.constantViolations) {
+ if (violation.scope !== binding.path.scope) {
+ state.mutableBinding = true;
+ path.stop();
+ return;
+ }
+ }
+
+ if (binding !== state.scope.getBinding(path.node.name)) return;
+ state.bindings[path.node.name] = binding;
+ }
+
+};
+
+class PathHoister {
+ constructor(path, scope) {
+ this.breakOnScopePaths = void 0;
+ this.bindings = void 0;
+ this.mutableBinding = void 0;
+ this.scopes = void 0;
+ this.scope = void 0;
+ this.path = void 0;
+ this.attachAfter = void 0;
+ this.breakOnScopePaths = [];
+ this.bindings = {};
+ this.mutableBinding = false;
+ this.scopes = [];
+ this.scope = scope;
+ this.path = path;
+ this.attachAfter = false;
+ }
+
+ isCompatibleScope(scope) {
+ for (const key of Object.keys(this.bindings)) {
+ const binding = this.bindings[key];
+
+ if (!scope.bindingIdentifierEquals(key, binding.identifier)) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ getCompatibleScopes() {
+ let scope = this.path.scope;
+
+ do {
+ if (this.isCompatibleScope(scope)) {
+ this.scopes.push(scope);
+ } else {
+ break;
+ }
+
+ if (this.breakOnScopePaths.indexOf(scope.path) >= 0) {
+ break;
+ }
+ } while (scope = scope.parent);
+ }
+
+ getAttachmentPath() {
+ let path = this._getAttachmentPath();
+
+ if (!path) return;
+ let targetScope = path.scope;
+
+ if (targetScope.path === path) {
+ targetScope = path.scope.parent;
+ }
+
+ if (targetScope.path.isProgram() || targetScope.path.isFunction()) {
+ for (const name of Object.keys(this.bindings)) {
+ if (!targetScope.hasOwnBinding(name)) continue;
+ const binding = this.bindings[name];
+
+ if (binding.kind === "param" || binding.path.parentKey === "params") {
+ continue;
+ }
+
+ const bindingParentPath = this.getAttachmentParentForPath(binding.path);
+
+ if (bindingParentPath.key >= path.key) {
+ this.attachAfter = true;
+ path = binding.path;
+
+ for (const violationPath of binding.constantViolations) {
+ if (this.getAttachmentParentForPath(violationPath).key > path.key) {
+ path = violationPath;
+ }
+ }
+ }
+ }
+ }
+
+ return path;
+ }
+
+ _getAttachmentPath() {
+ const scopes = this.scopes;
+ const scope = scopes.pop();
+ if (!scope) return;
+
+ if (scope.path.isFunction()) {
+ if (this.hasOwnParamBindings(scope)) {
+ if (this.scope === scope) return;
+ const bodies = scope.path.get("body").get("body");
+
+ for (let i = 0; i < bodies.length; i++) {
+ if (bodies[i].node._blockHoist) continue;
+ return bodies[i];
+ }
+ } else {
+ return this.getNextScopeAttachmentParent();
+ }
+ } else if (scope.path.isProgram()) {
+ return this.getNextScopeAttachmentParent();
+ }
+ }
+
+ getNextScopeAttachmentParent() {
+ const scope = this.scopes.pop();
+ if (scope) return this.getAttachmentParentForPath(scope.path);
+ }
+
+ getAttachmentParentForPath(path) {
+ do {
+ if (!path.parentPath || Array.isArray(path.container) && path.isStatement()) {
+ return path;
+ }
+ } while (path = path.parentPath);
+ }
+
+ hasOwnParamBindings(scope) {
+ for (const name of Object.keys(this.bindings)) {
+ if (!scope.hasOwnBinding(name)) continue;
+ const binding = this.bindings[name];
+ if (binding.kind === "param" && binding.constant) return true;
+ }
+
+ return false;
+ }
+
+ run() {
+ this.path.traverse(referenceVisitor, this);
+ if (this.mutableBinding) return;
+ this.getCompatibleScopes();
+ const attachTo = this.getAttachmentPath();
+ if (!attachTo) return;
+ if (attachTo.getFunctionParent() === this.path.getFunctionParent()) return;
+ let uid = attachTo.scope.generateUidIdentifier("ref");
+ const declarator = variableDeclarator(uid, this.path.node);
+ const insertFn = this.attachAfter ? "insertAfter" : "insertBefore";
+ const [attached] = attachTo[insertFn]([attachTo.isVariableDeclarator() ? declarator : variableDeclaration("var", [declarator])]);
+ const parent = this.path.parentPath;
+
+ if (parent.isJSXElement() && this.path.container === parent.node.children) {
+ uid = jsxExpressionContainer(uid);
+ }
+
+ this.path.replaceWith(cloneNode(uid));
+ return attachTo.isVariableDeclarator() ? attached.get("init") : attached.get("declarations.0.init");
+ }
+
+}
+
+exports.default = PathHoister;
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/lib/path/lib/removal-hooks.js b/node_modules/@babel/traverse/lib/path/lib/removal-hooks.js
new file mode 100644
index 000000000..23ec8fe6d
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/path/lib/removal-hooks.js
@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.hooks = void 0;
+const hooks = [function (self, parent) {
+ const removeParent = self.key === "test" && (parent.isWhile() || parent.isSwitchCase()) || self.key === "declaration" && parent.isExportDeclaration() || self.key === "body" && parent.isLabeledStatement() || self.listKey === "declarations" && parent.isVariableDeclaration() && parent.node.declarations.length === 1 || self.key === "expression" && parent.isExpressionStatement();
+
+ if (removeParent) {
+ parent.remove();
+ return true;
+ }
+}, function (self, parent) {
+ if (parent.isSequenceExpression() && parent.node.expressions.length === 1) {
+ parent.replaceWith(parent.node.expressions[0]);
+ return true;
+ }
+}, function (self, parent) {
+ if (parent.isBinary()) {
+ if (self.key === "left") {
+ parent.replaceWith(parent.node.right);
+ } else {
+ parent.replaceWith(parent.node.left);
+ }
+
+ return true;
+ }
+}, function (self, parent) {
+ if (parent.isIfStatement() && (self.key === "consequent" || self.key === "alternate") || self.key === "body" && (parent.isLoop() || parent.isArrowFunctionExpression())) {
+ self.replaceWith({
+ type: "BlockStatement",
+ body: []
+ });
+ return true;
+ }
+}];
+exports.hooks = hooks;
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/lib/path/lib/virtual-types.js b/node_modules/@babel/traverse/lib/path/lib/virtual-types.js
new file mode 100644
index 000000000..871cb249d
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/path/lib/virtual-types.js
@@ -0,0 +1,230 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.Var = exports.User = exports.Statement = exports.SpreadProperty = exports.Scope = exports.RestProperty = exports.ReferencedMemberExpression = exports.ReferencedIdentifier = exports.Referenced = exports.Pure = exports.NumericLiteralTypeAnnotation = exports.Generated = exports.ForAwaitStatement = exports.Flow = exports.Expression = exports.ExistentialTypeParam = exports.BlockScoped = exports.BindingIdentifier = void 0;
+
+var _t = require("@babel/types");
+
+const {
+ isBinding,
+ isBlockScoped,
+ isExportDeclaration,
+ isExpression,
+ isFlow,
+ isForStatement,
+ isForXStatement,
+ isIdentifier,
+ isImportDeclaration,
+ isImportSpecifier,
+ isJSXIdentifier,
+ isJSXMemberExpression,
+ isMemberExpression,
+ isReferenced,
+ isScope,
+ isStatement,
+ isVar,
+ isVariableDeclaration,
+ react
+} = _t;
+const {
+ isCompatTag
+} = react;
+const ReferencedIdentifier = {
+ types: ["Identifier", "JSXIdentifier"],
+
+ checkPath(path, opts) {
+ const {
+ node,
+ parent
+ } = path;
+
+ if (!isIdentifier(node, opts) && !isJSXMemberExpression(parent, opts)) {
+ if (isJSXIdentifier(node, opts)) {
+ if (isCompatTag(node.name)) return false;
+ } else {
+ return false;
+ }
+ }
+
+ return isReferenced(node, parent, path.parentPath.parent);
+ }
+
+};
+exports.ReferencedIdentifier = ReferencedIdentifier;
+const ReferencedMemberExpression = {
+ types: ["MemberExpression"],
+
+ checkPath({
+ node,
+ parent
+ }) {
+ return isMemberExpression(node) && isReferenced(node, parent);
+ }
+
+};
+exports.ReferencedMemberExpression = ReferencedMemberExpression;
+const BindingIdentifier = {
+ types: ["Identifier"],
+
+ checkPath(path) {
+ const {
+ node,
+ parent
+ } = path;
+ const grandparent = path.parentPath.parent;
+ return isIdentifier(node) && isBinding(node, parent, grandparent);
+ }
+
+};
+exports.BindingIdentifier = BindingIdentifier;
+const Statement = {
+ types: ["Statement"],
+
+ checkPath({
+ node,
+ parent
+ }) {
+ if (isStatement(node)) {
+ if (isVariableDeclaration(node)) {
+ if (isForXStatement(parent, {
+ left: node
+ })) return false;
+ if (isForStatement(parent, {
+ init: node
+ })) return false;
+ }
+
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+};
+exports.Statement = Statement;
+const Expression = {
+ types: ["Expression"],
+
+ checkPath(path) {
+ if (path.isIdentifier()) {
+ return path.isReferencedIdentifier();
+ } else {
+ return isExpression(path.node);
+ }
+ }
+
+};
+exports.Expression = Expression;
+const Scope = {
+ types: ["Scopable", "Pattern"],
+
+ checkPath(path) {
+ return isScope(path.node, path.parent);
+ }
+
+};
+exports.Scope = Scope;
+const Referenced = {
+ checkPath(path) {
+ return isReferenced(path.node, path.parent);
+ }
+
+};
+exports.Referenced = Referenced;
+const BlockScoped = {
+ checkPath(path) {
+ return isBlockScoped(path.node);
+ }
+
+};
+exports.BlockScoped = BlockScoped;
+const Var = {
+ types: ["VariableDeclaration"],
+
+ checkPath(path) {
+ return isVar(path.node);
+ }
+
+};
+exports.Var = Var;
+const User = {
+ checkPath(path) {
+ return path.node && !!path.node.loc;
+ }
+
+};
+exports.User = User;
+const Generated = {
+ checkPath(path) {
+ return !path.isUser();
+ }
+
+};
+exports.Generated = Generated;
+const Pure = {
+ checkPath(path, opts) {
+ return path.scope.isPure(path.node, opts);
+ }
+
+};
+exports.Pure = Pure;
+const Flow = {
+ types: ["Flow", "ImportDeclaration", "ExportDeclaration", "ImportSpecifier"],
+
+ checkPath({
+ node
+ }) {
+ if (isFlow(node)) {
+ return true;
+ } else if (isImportDeclaration(node)) {
+ return node.importKind === "type" || node.importKind === "typeof";
+ } else if (isExportDeclaration(node)) {
+ return node.exportKind === "type";
+ } else if (isImportSpecifier(node)) {
+ return node.importKind === "type" || node.importKind === "typeof";
+ } else {
+ return false;
+ }
+ }
+
+};
+exports.Flow = Flow;
+const RestProperty = {
+ types: ["RestElement"],
+
+ checkPath(path) {
+ return path.parentPath && path.parentPath.isObjectPattern();
+ }
+
+};
+exports.RestProperty = RestProperty;
+const SpreadProperty = {
+ types: ["RestElement"],
+
+ checkPath(path) {
+ return path.parentPath && path.parentPath.isObjectExpression();
+ }
+
+};
+exports.SpreadProperty = SpreadProperty;
+const ExistentialTypeParam = {
+ types: ["ExistsTypeAnnotation"]
+};
+exports.ExistentialTypeParam = ExistentialTypeParam;
+const NumericLiteralTypeAnnotation = {
+ types: ["NumberLiteralTypeAnnotation"]
+};
+exports.NumericLiteralTypeAnnotation = NumericLiteralTypeAnnotation;
+const ForAwaitStatement = {
+ types: ["ForOfStatement"],
+
+ checkPath({
+ node
+ }) {
+ return node.await === true;
+ }
+
+};
+exports.ForAwaitStatement = ForAwaitStatement;
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/lib/path/modification.js b/node_modules/@babel/traverse/lib/path/modification.js
new file mode 100644
index 000000000..c5de87b1c
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/path/modification.js
@@ -0,0 +1,269 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports._containerInsert = _containerInsert;
+exports._containerInsertAfter = _containerInsertAfter;
+exports._containerInsertBefore = _containerInsertBefore;
+exports._verifyNodeList = _verifyNodeList;
+exports.hoist = hoist;
+exports.insertAfter = insertAfter;
+exports.insertBefore = insertBefore;
+exports.pushContainer = pushContainer;
+exports.unshiftContainer = unshiftContainer;
+exports.updateSiblingKeys = updateSiblingKeys;
+
+var _cache = require("../cache");
+
+var _hoister = require("./lib/hoister");
+
+var _index = require("./index");
+
+var _t = require("@babel/types");
+
+const {
+ arrowFunctionExpression,
+ assertExpression,
+ assignmentExpression,
+ blockStatement,
+ callExpression,
+ cloneNode,
+ expressionStatement,
+ isAssignmentExpression,
+ isCallExpression,
+ isExpression,
+ isIdentifier,
+ isSequenceExpression,
+ isSuper,
+ thisExpression
+} = _t;
+
+function insertBefore(nodes_) {
+ this._assertUnremoved();
+
+ const nodes = this._verifyNodeList(nodes_);
+
+ const {
+ parentPath
+ } = this;
+
+ if (parentPath.isExpressionStatement() || parentPath.isLabeledStatement() || parentPath.isExportNamedDeclaration() || parentPath.isExportDefaultDeclaration() && this.isDeclaration()) {
+ return parentPath.insertBefore(nodes);
+ } else if (this.isNodeType("Expression") && !this.isJSXElement() || parentPath.isForStatement() && this.key === "init") {
+ if (this.node) nodes.push(this.node);
+ return this.replaceExpressionWithStatements(nodes);
+ } else if (Array.isArray(this.container)) {
+ return this._containerInsertBefore(nodes);
+ } else if (this.isStatementOrBlock()) {
+ const node = this.node;
+ const shouldInsertCurrentNode = node && (!this.isExpressionStatement() || node.expression != null);
+ this.replaceWith(blockStatement(shouldInsertCurrentNode ? [node] : []));
+ return this.unshiftContainer("body", nodes);
+ } else {
+ throw new Error("We don't know what to do with this node type. " + "We were previously a Statement but we can't fit in here?");
+ }
+}
+
+function _containerInsert(from, nodes) {
+ this.updateSiblingKeys(from, nodes.length);
+ const paths = [];
+ this.container.splice(from, 0, ...nodes);
+
+ for (let i = 0; i < nodes.length; i++) {
+ const to = from + i;
+ const path = this.getSibling(to);
+ paths.push(path);
+
+ if (this.context && this.context.queue) {
+ path.pushContext(this.context);
+ }
+ }
+
+ const contexts = this._getQueueContexts();
+
+ for (const path of paths) {
+ path.setScope();
+ path.debug("Inserted.");
+
+ for (const context of contexts) {
+ context.maybeQueue(path, true);
+ }
+ }
+
+ return paths;
+}
+
+function _containerInsertBefore(nodes) {
+ return this._containerInsert(this.key, nodes);
+}
+
+function _containerInsertAfter(nodes) {
+ return this._containerInsert(this.key + 1, nodes);
+}
+
+const last = arr => arr[arr.length - 1];
+
+function isHiddenInSequenceExpression(path) {
+ return isSequenceExpression(path.parent) && (last(path.parent.expressions) !== path.node || isHiddenInSequenceExpression(path.parentPath));
+}
+
+function isAlmostConstantAssignment(node, scope) {
+ if (!isAssignmentExpression(node) || !isIdentifier(node.left)) {
+ return false;
+ }
+
+ const blockScope = scope.getBlockParent();
+ return blockScope.hasOwnBinding(node.left.name) && blockScope.getOwnBinding(node.left.name).constantViolations.length <= 1;
+}
+
+function insertAfter(nodes_) {
+ this._assertUnremoved();
+
+ if (this.isSequenceExpression()) {
+ return last(this.get("expressions")).insertAfter(nodes_);
+ }
+
+ const nodes = this._verifyNodeList(nodes_);
+
+ const {
+ parentPath
+ } = this;
+
+ if (parentPath.isExpressionStatement() || parentPath.isLabeledStatement() || parentPath.isExportNamedDeclaration() || parentPath.isExportDefaultDeclaration() && this.isDeclaration()) {
+ return parentPath.insertAfter(nodes.map(node => {
+ return isExpression(node) ? expressionStatement(node) : node;
+ }));
+ } else if (this.isNodeType("Expression") && !this.isJSXElement() && !parentPath.isJSXElement() || parentPath.isForStatement() && this.key === "init") {
+ if (this.node) {
+ const node = this.node;
+ let {
+ scope
+ } = this;
+
+ if (scope.path.isPattern()) {
+ assertExpression(node);
+ this.replaceWith(callExpression(arrowFunctionExpression([], node), []));
+ this.get("callee.body").insertAfter(nodes);
+ return [this];
+ }
+
+ if (isHiddenInSequenceExpression(this)) {
+ nodes.unshift(node);
+ } else if (isCallExpression(node) && isSuper(node.callee)) {
+ nodes.unshift(node);
+ nodes.push(thisExpression());
+ } else if (isAlmostConstantAssignment(node, scope)) {
+ nodes.unshift(node);
+ nodes.push(cloneNode(node.left));
+ } else if (scope.isPure(node, true)) {
+ nodes.push(node);
+ } else {
+ if (parentPath.isMethod({
+ computed: true,
+ key: node
+ })) {
+ scope = scope.parent;
+ }
+
+ const temp = scope.generateDeclaredUidIdentifier();
+ nodes.unshift(expressionStatement(assignmentExpression("=", cloneNode(temp), node)));
+ nodes.push(expressionStatement(cloneNode(temp)));
+ }
+ }
+
+ return this.replaceExpressionWithStatements(nodes);
+ } else if (Array.isArray(this.container)) {
+ return this._containerInsertAfter(nodes);
+ } else if (this.isStatementOrBlock()) {
+ const node = this.node;
+ const shouldInsertCurrentNode = node && (!this.isExpressionStatement() || node.expression != null);
+ this.replaceWith(blockStatement(shouldInsertCurrentNode ? [node] : []));
+ return this.pushContainer("body", nodes);
+ } else {
+ throw new Error("We don't know what to do with this node type. " + "We were previously a Statement but we can't fit in here?");
+ }
+}
+
+function updateSiblingKeys(fromIndex, incrementBy) {
+ if (!this.parent) return;
+
+ const paths = _cache.path.get(this.parent);
+
+ for (const [, path] of paths) {
+ if (path.key >= fromIndex) {
+ path.key += incrementBy;
+ }
+ }
+}
+
+function _verifyNodeList(nodes) {
+ if (!nodes) {
+ return [];
+ }
+
+ if (!Array.isArray(nodes)) {
+ nodes = [nodes];
+ }
+
+ for (let i = 0; i < nodes.length; i++) {
+ const node = nodes[i];
+ let msg;
+
+ if (!node) {
+ msg = "has falsy node";
+ } else if (typeof node !== "object") {
+ msg = "contains a non-object node";
+ } else if (!node.type) {
+ msg = "without a type";
+ } else if (node instanceof _index.default) {
+ msg = "has a NodePath when it expected a raw object";
+ }
+
+ if (msg) {
+ const type = Array.isArray(node) ? "array" : typeof node;
+ throw new Error(`Node list ${msg} with the index of ${i} and type of ${type}`);
+ }
+ }
+
+ return nodes;
+}
+
+function unshiftContainer(listKey, nodes) {
+ this._assertUnremoved();
+
+ nodes = this._verifyNodeList(nodes);
+
+ const path = _index.default.get({
+ parentPath: this,
+ parent: this.node,
+ container: this.node[listKey],
+ listKey,
+ key: 0
+ }).setContext(this.context);
+
+ return path._containerInsertBefore(nodes);
+}
+
+function pushContainer(listKey, nodes) {
+ this._assertUnremoved();
+
+ const verifiedNodes = this._verifyNodeList(nodes);
+
+ const container = this.node[listKey];
+
+ const path = _index.default.get({
+ parentPath: this,
+ parent: this.node,
+ container: container,
+ listKey,
+ key: container.length
+ }).setContext(this.context);
+
+ return path.replaceWithMultiple(verifiedNodes);
+}
+
+function hoist(scope = this.scope) {
+ const hoister = new _hoister.default(this, scope);
+ return hoister.run();
+}
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/lib/path/removal.js b/node_modules/@babel/traverse/lib/path/removal.js
new file mode 100644
index 000000000..3e5d4fff0
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/path/removal.js
@@ -0,0 +1,73 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports._assertUnremoved = _assertUnremoved;
+exports._callRemovalHooks = _callRemovalHooks;
+exports._markRemoved = _markRemoved;
+exports._remove = _remove;
+exports._removeFromScope = _removeFromScope;
+exports.remove = remove;
+
+var _removalHooks = require("./lib/removal-hooks");
+
+var _cache = require("../cache");
+
+var _index = require("./index");
+
+function remove() {
+ var _this$opts;
+
+ this._assertUnremoved();
+
+ this.resync();
+
+ if (!((_this$opts = this.opts) != null && _this$opts.noScope)) {
+ this._removeFromScope();
+ }
+
+ if (this._callRemovalHooks()) {
+ this._markRemoved();
+
+ return;
+ }
+
+ this.shareCommentsWithSiblings();
+
+ this._remove();
+
+ this._markRemoved();
+}
+
+function _removeFromScope() {
+ const bindings = this.getBindingIdentifiers();
+ Object.keys(bindings).forEach(name => this.scope.removeBinding(name));
+}
+
+function _callRemovalHooks() {
+ for (const fn of _removalHooks.hooks) {
+ if (fn(this, this.parentPath)) return true;
+ }
+}
+
+function _remove() {
+ if (Array.isArray(this.container)) {
+ this.container.splice(this.key, 1);
+ this.updateSiblingKeys(this.key, -1);
+ } else {
+ this._replaceWith(null);
+ }
+}
+
+function _markRemoved() {
+ this._traverseFlags |= _index.SHOULD_SKIP | _index.REMOVED;
+ if (this.parent) _cache.path.get(this.parent).delete(this.node);
+ this.node = null;
+}
+
+function _assertUnremoved() {
+ if (this.removed) {
+ throw this.buildCodeFrameError("NodePath has been removed so is read-only.");
+ }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/lib/path/replacement.js b/node_modules/@babel/traverse/lib/path/replacement.js
new file mode 100644
index 000000000..ee5cdce8e
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/path/replacement.js
@@ -0,0 +1,260 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports._replaceWith = _replaceWith;
+exports.replaceExpressionWithStatements = replaceExpressionWithStatements;
+exports.replaceInline = replaceInline;
+exports.replaceWith = replaceWith;
+exports.replaceWithMultiple = replaceWithMultiple;
+exports.replaceWithSourceString = replaceWithSourceString;
+
+var _codeFrame = require("@babel/code-frame");
+
+var _index = require("../index");
+
+var _index2 = require("./index");
+
+var _cache = require("../cache");
+
+var _parser = require("@babel/parser");
+
+var _t = require("@babel/types");
+
+var _helperHoistVariables = require("@babel/helper-hoist-variables");
+
+const {
+ FUNCTION_TYPES,
+ arrowFunctionExpression,
+ assignmentExpression,
+ awaitExpression,
+ blockStatement,
+ callExpression,
+ cloneNode,
+ expressionStatement,
+ identifier,
+ inheritLeadingComments,
+ inheritTrailingComments,
+ inheritsComments,
+ isExpression,
+ isProgram,
+ isStatement,
+ removeComments,
+ returnStatement,
+ toSequenceExpression,
+ validate,
+ yieldExpression
+} = _t;
+
+function replaceWithMultiple(nodes) {
+ var _pathCache$get;
+
+ this.resync();
+ nodes = this._verifyNodeList(nodes);
+ inheritLeadingComments(nodes[0], this.node);
+ inheritTrailingComments(nodes[nodes.length - 1], this.node);
+ (_pathCache$get = _cache.path.get(this.parent)) == null ? void 0 : _pathCache$get.delete(this.node);
+ this.node = this.container[this.key] = null;
+ const paths = this.insertAfter(nodes);
+
+ if (this.node) {
+ this.requeue();
+ } else {
+ this.remove();
+ }
+
+ return paths;
+}
+
+function replaceWithSourceString(replacement) {
+ this.resync();
+
+ try {
+ replacement = `(${replacement})`;
+ replacement = (0, _parser.parse)(replacement);
+ } catch (err) {
+ const loc = err.loc;
+
+ if (loc) {
+ err.message += " - make sure this is an expression.\n" + (0, _codeFrame.codeFrameColumns)(replacement, {
+ start: {
+ line: loc.line,
+ column: loc.column + 1
+ }
+ });
+ err.code = "BABEL_REPLACE_SOURCE_ERROR";
+ }
+
+ throw err;
+ }
+
+ replacement = replacement.program.body[0].expression;
+
+ _index.default.removeProperties(replacement);
+
+ return this.replaceWith(replacement);
+}
+
+function replaceWith(replacement) {
+ this.resync();
+
+ if (this.removed) {
+ throw new Error("You can't replace this node, we've already removed it");
+ }
+
+ if (replacement instanceof _index2.default) {
+ replacement = replacement.node;
+ }
+
+ if (!replacement) {
+ throw new Error("You passed `path.replaceWith()` a falsy node, use `path.remove()` instead");
+ }
+
+ if (this.node === replacement) {
+ return [this];
+ }
+
+ if (this.isProgram() && !isProgram(replacement)) {
+ throw new Error("You can only replace a Program root node with another Program node");
+ }
+
+ if (Array.isArray(replacement)) {
+ throw new Error("Don't use `path.replaceWith()` with an array of nodes, use `path.replaceWithMultiple()`");
+ }
+
+ if (typeof replacement === "string") {
+ throw new Error("Don't use `path.replaceWith()` with a source string, use `path.replaceWithSourceString()`");
+ }
+
+ let nodePath = "";
+
+ if (this.isNodeType("Statement") && isExpression(replacement)) {
+ if (!this.canHaveVariableDeclarationOrExpression() && !this.canSwapBetweenExpressionAndStatement(replacement) && !this.parentPath.isExportDefaultDeclaration()) {
+ replacement = expressionStatement(replacement);
+ nodePath = "expression";
+ }
+ }
+
+ if (this.isNodeType("Expression") && isStatement(replacement)) {
+ if (!this.canHaveVariableDeclarationOrExpression() && !this.canSwapBetweenExpressionAndStatement(replacement)) {
+ return this.replaceExpressionWithStatements([replacement]);
+ }
+ }
+
+ const oldNode = this.node;
+
+ if (oldNode) {
+ inheritsComments(replacement, oldNode);
+ removeComments(oldNode);
+ }
+
+ this._replaceWith(replacement);
+
+ this.type = replacement.type;
+ this.setScope();
+ this.requeue();
+ return [nodePath ? this.get(nodePath) : this];
+}
+
+function _replaceWith(node) {
+ var _pathCache$get2;
+
+ if (!this.container) {
+ throw new ReferenceError("Container is falsy");
+ }
+
+ if (this.inList) {
+ validate(this.parent, this.key, [node]);
+ } else {
+ validate(this.parent, this.key, node);
+ }
+
+ this.debug(`Replace with ${node == null ? void 0 : node.type}`);
+ (_pathCache$get2 = _cache.path.get(this.parent)) == null ? void 0 : _pathCache$get2.set(node, this).delete(this.node);
+ this.node = this.container[this.key] = node;
+}
+
+function replaceExpressionWithStatements(nodes) {
+ this.resync();
+ const nodesAsSequenceExpression = toSequenceExpression(nodes, this.scope);
+
+ if (nodesAsSequenceExpression) {
+ return this.replaceWith(nodesAsSequenceExpression)[0].get("expressions");
+ }
+
+ const functionParent = this.getFunctionParent();
+ const isParentAsync = functionParent == null ? void 0 : functionParent.is("async");
+ const isParentGenerator = functionParent == null ? void 0 : functionParent.is("generator");
+ const container = arrowFunctionExpression([], blockStatement(nodes));
+ this.replaceWith(callExpression(container, []));
+ const callee = this.get("callee");
+ (0, _helperHoistVariables.default)(callee.get("body"), id => {
+ this.scope.push({
+ id
+ });
+ }, "var");
+ const completionRecords = this.get("callee").getCompletionRecords();
+
+ for (const path of completionRecords) {
+ if (!path.isExpressionStatement()) continue;
+ const loop = path.findParent(path => path.isLoop());
+
+ if (loop) {
+ let uid = loop.getData("expressionReplacementReturnUid");
+
+ if (!uid) {
+ uid = callee.scope.generateDeclaredUidIdentifier("ret");
+ callee.get("body").pushContainer("body", returnStatement(cloneNode(uid)));
+ loop.setData("expressionReplacementReturnUid", uid);
+ } else {
+ uid = identifier(uid.name);
+ }
+
+ path.get("expression").replaceWith(assignmentExpression("=", cloneNode(uid), path.node.expression));
+ } else {
+ path.replaceWith(returnStatement(path.node.expression));
+ }
+ }
+
+ callee.arrowFunctionToExpression();
+ const newCallee = callee;
+
+ const needToAwaitFunction = isParentAsync && _index.default.hasType(this.get("callee.body").node, "AwaitExpression", FUNCTION_TYPES);
+
+ const needToYieldFunction = isParentGenerator && _index.default.hasType(this.get("callee.body").node, "YieldExpression", FUNCTION_TYPES);
+
+ if (needToAwaitFunction) {
+ newCallee.set("async", true);
+
+ if (!needToYieldFunction) {
+ this.replaceWith(awaitExpression(this.node));
+ }
+ }
+
+ if (needToYieldFunction) {
+ newCallee.set("generator", true);
+ this.replaceWith(yieldExpression(this.node, true));
+ }
+
+ return newCallee.get("body.body");
+}
+
+function replaceInline(nodes) {
+ this.resync();
+
+ if (Array.isArray(nodes)) {
+ if (Array.isArray(this.container)) {
+ nodes = this._verifyNodeList(nodes);
+
+ const paths = this._containerInsertAfter(nodes);
+
+ this.remove();
+ return paths;
+ } else {
+ return this.replaceWithMultiple(nodes);
+ }
+ } else {
+ return this.replaceWith(nodes);
+ }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/lib/scope/binding.js b/node_modules/@babel/traverse/lib/scope/binding.js
new file mode 100644
index 000000000..16911ef21
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/scope/binding.js
@@ -0,0 +1,75 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = void 0;
+
+class Binding {
+ constructor({
+ identifier,
+ scope,
+ path,
+ kind
+ }) {
+ this.identifier = void 0;
+ this.scope = void 0;
+ this.path = void 0;
+ this.kind = void 0;
+ this.constantViolations = [];
+ this.constant = true;
+ this.referencePaths = [];
+ this.referenced = false;
+ this.references = 0;
+ this.identifier = identifier;
+ this.scope = scope;
+ this.path = path;
+ this.kind = kind;
+ this.clearValue();
+ }
+
+ deoptValue() {
+ this.clearValue();
+ this.hasDeoptedValue = true;
+ }
+
+ setValue(value) {
+ if (this.hasDeoptedValue) return;
+ this.hasValue = true;
+ this.value = value;
+ }
+
+ clearValue() {
+ this.hasDeoptedValue = false;
+ this.hasValue = false;
+ this.value = null;
+ }
+
+ reassign(path) {
+ this.constant = false;
+
+ if (this.constantViolations.indexOf(path) !== -1) {
+ return;
+ }
+
+ this.constantViolations.push(path);
+ }
+
+ reference(path) {
+ if (this.referencePaths.indexOf(path) !== -1) {
+ return;
+ }
+
+ this.referenced = true;
+ this.references++;
+ this.referencePaths.push(path);
+ }
+
+ dereference() {
+ this.references--;
+ this.referenced = !!this.references;
+ }
+
+}
+
+exports.default = Binding;
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/lib/scope/index.js b/node_modules/@babel/traverse/lib/scope/index.js
new file mode 100644
index 000000000..ee376a88f
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/scope/index.js
@@ -0,0 +1,1018 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = void 0;
+
+var _renamer = require("./lib/renamer");
+
+var _index = require("../index");
+
+var _binding = require("./binding");
+
+var _globals = require("globals");
+
+var _t = require("@babel/types");
+
+var _cache = require("../cache");
+
+const {
+ NOT_LOCAL_BINDING,
+ callExpression,
+ cloneNode,
+ getBindingIdentifiers,
+ identifier,
+ isArrayExpression,
+ isBinary,
+ isClass,
+ isClassBody,
+ isClassDeclaration,
+ isExportAllDeclaration,
+ isExportDefaultDeclaration,
+ isExportNamedDeclaration,
+ isFunctionDeclaration,
+ isIdentifier,
+ isImportDeclaration,
+ isLiteral,
+ isMethod,
+ isModuleDeclaration,
+ isModuleSpecifier,
+ isObjectExpression,
+ isProperty,
+ isPureish,
+ isSuper,
+ isTaggedTemplateExpression,
+ isTemplateLiteral,
+ isThisExpression,
+ isUnaryExpression,
+ isVariableDeclaration,
+ matchesPattern,
+ memberExpression,
+ numericLiteral,
+ toIdentifier,
+ unaryExpression,
+ variableDeclaration,
+ variableDeclarator
+} = _t;
+
+function gatherNodeParts(node, parts) {
+ switch (node == null ? void 0 : node.type) {
+ default:
+ if (isModuleDeclaration(node)) {
+ if ((isExportAllDeclaration(node) || isExportNamedDeclaration(node) || isImportDeclaration(node)) && node.source) {
+ gatherNodeParts(node.source, parts);
+ } else if ((isExportNamedDeclaration(node) || isImportDeclaration(node)) && node.specifiers && node.specifiers.length) {
+ for (const e of node.specifiers) gatherNodeParts(e, parts);
+ } else if ((isExportDefaultDeclaration(node) || isExportNamedDeclaration(node)) && node.declaration) {
+ gatherNodeParts(node.declaration, parts);
+ }
+ } else if (isModuleSpecifier(node)) {
+ gatherNodeParts(node.local, parts);
+ } else if (isLiteral(node)) {
+ parts.push(node.value);
+ }
+
+ break;
+
+ case "MemberExpression":
+ case "OptionalMemberExpression":
+ case "JSXMemberExpression":
+ gatherNodeParts(node.object, parts);
+ gatherNodeParts(node.property, parts);
+ break;
+
+ case "Identifier":
+ case "JSXIdentifier":
+ parts.push(node.name);
+ break;
+
+ case "CallExpression":
+ case "OptionalCallExpression":
+ case "NewExpression":
+ gatherNodeParts(node.callee, parts);
+ break;
+
+ case "ObjectExpression":
+ case "ObjectPattern":
+ for (const e of node.properties) {
+ gatherNodeParts(e, parts);
+ }
+
+ break;
+
+ case "SpreadElement":
+ case "RestElement":
+ gatherNodeParts(node.argument, parts);
+ break;
+
+ case "ObjectProperty":
+ case "ObjectMethod":
+ case "ClassProperty":
+ case "ClassMethod":
+ case "ClassPrivateProperty":
+ case "ClassPrivateMethod":
+ gatherNodeParts(node.key, parts);
+ break;
+
+ case "ThisExpression":
+ parts.push("this");
+ break;
+
+ case "Super":
+ parts.push("super");
+ break;
+
+ case "Import":
+ parts.push("import");
+ break;
+
+ case "DoExpression":
+ parts.push("do");
+ break;
+
+ case "YieldExpression":
+ parts.push("yield");
+ gatherNodeParts(node.argument, parts);
+ break;
+
+ case "AwaitExpression":
+ parts.push("await");
+ gatherNodeParts(node.argument, parts);
+ break;
+
+ case "AssignmentExpression":
+ gatherNodeParts(node.left, parts);
+ break;
+
+ case "VariableDeclarator":
+ gatherNodeParts(node.id, parts);
+ break;
+
+ case "FunctionExpression":
+ case "FunctionDeclaration":
+ case "ClassExpression":
+ case "ClassDeclaration":
+ gatherNodeParts(node.id, parts);
+ break;
+
+ case "PrivateName":
+ gatherNodeParts(node.id, parts);
+ break;
+
+ case "ParenthesizedExpression":
+ gatherNodeParts(node.expression, parts);
+ break;
+
+ case "UnaryExpression":
+ case "UpdateExpression":
+ gatherNodeParts(node.argument, parts);
+ break;
+
+ case "MetaProperty":
+ gatherNodeParts(node.meta, parts);
+ gatherNodeParts(node.property, parts);
+ break;
+
+ case "JSXElement":
+ gatherNodeParts(node.openingElement, parts);
+ break;
+
+ case "JSXOpeningElement":
+ parts.push(node.name);
+ break;
+
+ case "JSXFragment":
+ gatherNodeParts(node.openingFragment, parts);
+ break;
+
+ case "JSXOpeningFragment":
+ parts.push("Fragment");
+ break;
+
+ case "JSXNamespacedName":
+ gatherNodeParts(node.namespace, parts);
+ gatherNodeParts(node.name, parts);
+ break;
+ }
+}
+
+const collectorVisitor = {
+ ForStatement(path) {
+ const declar = path.get("init");
+
+ if (declar.isVar()) {
+ const {
+ scope
+ } = path;
+ const parentScope = scope.getFunctionParent() || scope.getProgramParent();
+ parentScope.registerBinding("var", declar);
+ }
+ },
+
+ Declaration(path) {
+ if (path.isBlockScoped()) return;
+ if (path.isImportDeclaration()) return;
+ if (path.isExportDeclaration()) return;
+ const parent = path.scope.getFunctionParent() || path.scope.getProgramParent();
+ parent.registerDeclaration(path);
+ },
+
+ ImportDeclaration(path) {
+ const parent = path.scope.getBlockParent();
+ parent.registerDeclaration(path);
+ },
+
+ ReferencedIdentifier(path, state) {
+ state.references.push(path);
+ },
+
+ ForXStatement(path, state) {
+ const left = path.get("left");
+
+ if (left.isPattern() || left.isIdentifier()) {
+ state.constantViolations.push(path);
+ } else if (left.isVar()) {
+ const {
+ scope
+ } = path;
+ const parentScope = scope.getFunctionParent() || scope.getProgramParent();
+ parentScope.registerBinding("var", left);
+ }
+ },
+
+ ExportDeclaration: {
+ exit(path) {
+ const {
+ node,
+ scope
+ } = path;
+ if (isExportAllDeclaration(node)) return;
+ const declar = node.declaration;
+
+ if (isClassDeclaration(declar) || isFunctionDeclaration(declar)) {
+ const id = declar.id;
+ if (!id) return;
+ const binding = scope.getBinding(id.name);
+ binding == null ? void 0 : binding.reference(path);
+ } else if (isVariableDeclaration(declar)) {
+ for (const decl of declar.declarations) {
+ for (const name of Object.keys(getBindingIdentifiers(decl))) {
+ const binding = scope.getBinding(name);
+ binding == null ? void 0 : binding.reference(path);
+ }
+ }
+ }
+ }
+
+ },
+
+ LabeledStatement(path) {
+ path.scope.getBlockParent().registerDeclaration(path);
+ },
+
+ AssignmentExpression(path, state) {
+ state.assignments.push(path);
+ },
+
+ UpdateExpression(path, state) {
+ state.constantViolations.push(path);
+ },
+
+ UnaryExpression(path, state) {
+ if (path.node.operator === "delete") {
+ state.constantViolations.push(path);
+ }
+ },
+
+ BlockScoped(path) {
+ let scope = path.scope;
+ if (scope.path === path) scope = scope.parent;
+ const parent = scope.getBlockParent();
+ parent.registerDeclaration(path);
+
+ if (path.isClassDeclaration() && path.node.id) {
+ const id = path.node.id;
+ const name = id.name;
+ path.scope.bindings[name] = path.scope.parent.getBinding(name);
+ }
+ },
+
+ CatchClause(path) {
+ path.scope.registerBinding("let", path);
+ },
+
+ Function(path) {
+ const params = path.get("params");
+
+ for (const param of params) {
+ path.scope.registerBinding("param", param);
+ }
+
+ if (path.isFunctionExpression() && path.has("id") && !path.get("id").node[NOT_LOCAL_BINDING]) {
+ path.scope.registerBinding("local", path.get("id"), path);
+ }
+ },
+
+ ClassExpression(path) {
+ if (path.has("id") && !path.get("id").node[NOT_LOCAL_BINDING]) {
+ path.scope.registerBinding("local", path);
+ }
+ }
+
+};
+let uid = 0;
+
+class Scope {
+ constructor(path) {
+ this.uid = void 0;
+ this.path = void 0;
+ this.block = void 0;
+ this.labels = void 0;
+ this.inited = void 0;
+ this.bindings = void 0;
+ this.references = void 0;
+ this.globals = void 0;
+ this.uids = void 0;
+ this.data = void 0;
+ this.crawling = void 0;
+ const {
+ node
+ } = path;
+
+ const cached = _cache.scope.get(node);
+
+ if ((cached == null ? void 0 : cached.path) === path) {
+ return cached;
+ }
+
+ _cache.scope.set(node, this);
+
+ this.uid = uid++;
+ this.block = node;
+ this.path = path;
+ this.labels = new Map();
+ this.inited = false;
+ }
+
+ get parent() {
+ var _parent;
+
+ let parent,
+ path = this.path;
+
+ do {
+ const isKey = path.key === "key";
+ path = path.parentPath;
+ if (isKey && path.isMethod()) path = path.parentPath;
+ if (path && path.isScope()) parent = path;
+ } while (path && !parent);
+
+ return (_parent = parent) == null ? void 0 : _parent.scope;
+ }
+
+ get parentBlock() {
+ return this.path.parent;
+ }
+
+ get hub() {
+ return this.path.hub;
+ }
+
+ traverse(node, opts, state) {
+ (0, _index.default)(node, opts, this, state, this.path);
+ }
+
+ generateDeclaredUidIdentifier(name) {
+ const id = this.generateUidIdentifier(name);
+ this.push({
+ id
+ });
+ return cloneNode(id);
+ }
+
+ generateUidIdentifier(name) {
+ return identifier(this.generateUid(name));
+ }
+
+ generateUid(name = "temp") {
+ name = toIdentifier(name).replace(/^_+/, "").replace(/[0-9]+$/g, "");
+ let uid;
+ let i = 1;
+
+ do {
+ uid = this._generateUid(name, i);
+ i++;
+ } while (this.hasLabel(uid) || this.hasBinding(uid) || this.hasGlobal(uid) || this.hasReference(uid));
+
+ const program = this.getProgramParent();
+ program.references[uid] = true;
+ program.uids[uid] = true;
+ return uid;
+ }
+
+ _generateUid(name, i) {
+ let id = name;
+ if (i > 1) id += i;
+ return `_${id}`;
+ }
+
+ generateUidBasedOnNode(node, defaultName) {
+ const parts = [];
+ gatherNodeParts(node, parts);
+ let id = parts.join("$");
+ id = id.replace(/^_/, "") || defaultName || "ref";
+ return this.generateUid(id.slice(0, 20));
+ }
+
+ generateUidIdentifierBasedOnNode(node, defaultName) {
+ return identifier(this.generateUidBasedOnNode(node, defaultName));
+ }
+
+ isStatic(node) {
+ if (isThisExpression(node) || isSuper(node)) {
+ return true;
+ }
+
+ if (isIdentifier(node)) {
+ const binding = this.getBinding(node.name);
+
+ if (binding) {
+ return binding.constant;
+ } else {
+ return this.hasBinding(node.name);
+ }
+ }
+
+ return false;
+ }
+
+ maybeGenerateMemoised(node, dontPush) {
+ if (this.isStatic(node)) {
+ return null;
+ } else {
+ const id = this.generateUidIdentifierBasedOnNode(node);
+
+ if (!dontPush) {
+ this.push({
+ id
+ });
+ return cloneNode(id);
+ }
+
+ return id;
+ }
+ }
+
+ checkBlockScopedCollisions(local, kind, name, id) {
+ if (kind === "param") return;
+ if (local.kind === "local") return;
+ const duplicate = kind === "let" || local.kind === "let" || local.kind === "const" || local.kind === "module" || local.kind === "param" && kind === "const";
+
+ if (duplicate) {
+ throw this.hub.buildError(id, `Duplicate declaration "${name}"`, TypeError);
+ }
+ }
+
+ rename(oldName, newName, block) {
+ const binding = this.getBinding(oldName);
+
+ if (binding) {
+ newName = newName || this.generateUidIdentifier(oldName).name;
+ return new _renamer.default(binding, oldName, newName).rename(block);
+ }
+ }
+
+ _renameFromMap(map, oldName, newName, value) {
+ if (map[oldName]) {
+ map[newName] = value;
+ map[oldName] = null;
+ }
+ }
+
+ dump() {
+ const sep = "-".repeat(60);
+ console.log(sep);
+ let scope = this;
+
+ do {
+ console.log("#", scope.block.type);
+
+ for (const name of Object.keys(scope.bindings)) {
+ const binding = scope.bindings[name];
+ console.log(" -", name, {
+ constant: binding.constant,
+ references: binding.references,
+ violations: binding.constantViolations.length,
+ kind: binding.kind
+ });
+ }
+ } while (scope = scope.parent);
+
+ console.log(sep);
+ }
+
+ toArray(node, i, arrayLikeIsIterable) {
+ if (isIdentifier(node)) {
+ const binding = this.getBinding(node.name);
+
+ if (binding != null && binding.constant && binding.path.isGenericType("Array")) {
+ return node;
+ }
+ }
+
+ if (isArrayExpression(node)) {
+ return node;
+ }
+
+ if (isIdentifier(node, {
+ name: "arguments"
+ })) {
+ return callExpression(memberExpression(memberExpression(memberExpression(identifier("Array"), identifier("prototype")), identifier("slice")), identifier("call")), [node]);
+ }
+
+ let helperName;
+ const args = [node];
+
+ if (i === true) {
+ helperName = "toConsumableArray";
+ } else if (i) {
+ args.push(numericLiteral(i));
+ helperName = "slicedToArray";
+ } else {
+ helperName = "toArray";
+ }
+
+ if (arrayLikeIsIterable) {
+ args.unshift(this.hub.addHelper(helperName));
+ helperName = "maybeArrayLike";
+ }
+
+ return callExpression(this.hub.addHelper(helperName), args);
+ }
+
+ hasLabel(name) {
+ return !!this.getLabel(name);
+ }
+
+ getLabel(name) {
+ return this.labels.get(name);
+ }
+
+ registerLabel(path) {
+ this.labels.set(path.node.label.name, path);
+ }
+
+ registerDeclaration(path) {
+ if (path.isLabeledStatement()) {
+ this.registerLabel(path);
+ } else if (path.isFunctionDeclaration()) {
+ this.registerBinding("hoisted", path.get("id"), path);
+ } else if (path.isVariableDeclaration()) {
+ const declarations = path.get("declarations");
+
+ for (const declar of declarations) {
+ this.registerBinding(path.node.kind, declar);
+ }
+ } else if (path.isClassDeclaration()) {
+ if (path.node.declare) return;
+ this.registerBinding("let", path);
+ } else if (path.isImportDeclaration()) {
+ const specifiers = path.get("specifiers");
+
+ for (const specifier of specifiers) {
+ this.registerBinding("module", specifier);
+ }
+ } else if (path.isExportDeclaration()) {
+ const declar = path.get("declaration");
+
+ if (declar.isClassDeclaration() || declar.isFunctionDeclaration() || declar.isVariableDeclaration()) {
+ this.registerDeclaration(declar);
+ }
+ } else {
+ this.registerBinding("unknown", path);
+ }
+ }
+
+ buildUndefinedNode() {
+ return unaryExpression("void", numericLiteral(0), true);
+ }
+
+ registerConstantViolation(path) {
+ const ids = path.getBindingIdentifiers();
+
+ for (const name of Object.keys(ids)) {
+ const binding = this.getBinding(name);
+ if (binding) binding.reassign(path);
+ }
+ }
+
+ registerBinding(kind, path, bindingPath = path) {
+ if (!kind) throw new ReferenceError("no `kind`");
+
+ if (path.isVariableDeclaration()) {
+ const declarators = path.get("declarations");
+
+ for (const declar of declarators) {
+ this.registerBinding(kind, declar);
+ }
+
+ return;
+ }
+
+ const parent = this.getProgramParent();
+ const ids = path.getOuterBindingIdentifiers(true);
+
+ for (const name of Object.keys(ids)) {
+ parent.references[name] = true;
+
+ for (const id of ids[name]) {
+ const local = this.getOwnBinding(name);
+
+ if (local) {
+ if (local.identifier === id) continue;
+ this.checkBlockScopedCollisions(local, kind, name, id);
+ }
+
+ if (local) {
+ this.registerConstantViolation(bindingPath);
+ } else {
+ this.bindings[name] = new _binding.default({
+ identifier: id,
+ scope: this,
+ path: bindingPath,
+ kind: kind
+ });
+ }
+ }
+ }
+ }
+
+ addGlobal(node) {
+ this.globals[node.name] = node;
+ }
+
+ hasUid(name) {
+ let scope = this;
+
+ do {
+ if (scope.uids[name]) return true;
+ } while (scope = scope.parent);
+
+ return false;
+ }
+
+ hasGlobal(name) {
+ let scope = this;
+
+ do {
+ if (scope.globals[name]) return true;
+ } while (scope = scope.parent);
+
+ return false;
+ }
+
+ hasReference(name) {
+ return !!this.getProgramParent().references[name];
+ }
+
+ isPure(node, constantsOnly) {
+ if (isIdentifier(node)) {
+ const binding = this.getBinding(node.name);
+ if (!binding) return false;
+ if (constantsOnly) return binding.constant;
+ return true;
+ } else if (isClass(node)) {
+ if (node.superClass && !this.isPure(node.superClass, constantsOnly)) {
+ return false;
+ }
+
+ return this.isPure(node.body, constantsOnly);
+ } else if (isClassBody(node)) {
+ for (const method of node.body) {
+ if (!this.isPure(method, constantsOnly)) return false;
+ }
+
+ return true;
+ } else if (isBinary(node)) {
+ return this.isPure(node.left, constantsOnly) && this.isPure(node.right, constantsOnly);
+ } else if (isArrayExpression(node)) {
+ for (const elem of node.elements) {
+ if (!this.isPure(elem, constantsOnly)) return false;
+ }
+
+ return true;
+ } else if (isObjectExpression(node)) {
+ for (const prop of node.properties) {
+ if (!this.isPure(prop, constantsOnly)) return false;
+ }
+
+ return true;
+ } else if (isMethod(node)) {
+ if (node.computed && !this.isPure(node.key, constantsOnly)) return false;
+ if (node.kind === "get" || node.kind === "set") return false;
+ return true;
+ } else if (isProperty(node)) {
+ if (node.computed && !this.isPure(node.key, constantsOnly)) return false;
+ return this.isPure(node.value, constantsOnly);
+ } else if (isUnaryExpression(node)) {
+ return this.isPure(node.argument, constantsOnly);
+ } else if (isTaggedTemplateExpression(node)) {
+ return matchesPattern(node.tag, "String.raw") && !this.hasBinding("String", true) && this.isPure(node.quasi, constantsOnly);
+ } else if (isTemplateLiteral(node)) {
+ for (const expression of node.expressions) {
+ if (!this.isPure(expression, constantsOnly)) return false;
+ }
+
+ return true;
+ } else {
+ return isPureish(node);
+ }
+ }
+
+ setData(key, val) {
+ return this.data[key] = val;
+ }
+
+ getData(key) {
+ let scope = this;
+
+ do {
+ const data = scope.data[key];
+ if (data != null) return data;
+ } while (scope = scope.parent);
+ }
+
+ removeData(key) {
+ let scope = this;
+
+ do {
+ const data = scope.data[key];
+ if (data != null) scope.data[key] = null;
+ } while (scope = scope.parent);
+ }
+
+ init() {
+ if (!this.inited) {
+ this.inited = true;
+ this.crawl();
+ }
+ }
+
+ crawl() {
+ const path = this.path;
+ this.references = Object.create(null);
+ this.bindings = Object.create(null);
+ this.globals = Object.create(null);
+ this.uids = Object.create(null);
+ this.data = Object.create(null);
+ const programParent = this.getProgramParent();
+ if (programParent.crawling) return;
+ const state = {
+ references: [],
+ constantViolations: [],
+ assignments: []
+ };
+ this.crawling = true;
+
+ if (path.type !== "Program" && collectorVisitor._exploded) {
+ for (const visit of collectorVisitor.enter) {
+ visit(path, state);
+ }
+
+ const typeVisitors = collectorVisitor[path.type];
+
+ if (typeVisitors) {
+ for (const visit of typeVisitors.enter) {
+ visit(path, state);
+ }
+ }
+ }
+
+ path.traverse(collectorVisitor, state);
+ this.crawling = false;
+
+ for (const path of state.assignments) {
+ const ids = path.getBindingIdentifiers();
+
+ for (const name of Object.keys(ids)) {
+ if (path.scope.getBinding(name)) continue;
+ programParent.addGlobal(ids[name]);
+ }
+
+ path.scope.registerConstantViolation(path);
+ }
+
+ for (const ref of state.references) {
+ const binding = ref.scope.getBinding(ref.node.name);
+
+ if (binding) {
+ binding.reference(ref);
+ } else {
+ programParent.addGlobal(ref.node);
+ }
+ }
+
+ for (const path of state.constantViolations) {
+ path.scope.registerConstantViolation(path);
+ }
+ }
+
+ push(opts) {
+ let path = this.path;
+
+ if (!path.isBlockStatement() && !path.isProgram()) {
+ path = this.getBlockParent().path;
+ }
+
+ if (path.isSwitchStatement()) {
+ path = (this.getFunctionParent() || this.getProgramParent()).path;
+ }
+
+ if (path.isLoop() || path.isCatchClause() || path.isFunction()) {
+ path.ensureBlock();
+ path = path.get("body");
+ }
+
+ const unique = opts.unique;
+ const kind = opts.kind || "var";
+ const blockHoist = opts._blockHoist == null ? 2 : opts._blockHoist;
+ const dataKey = `declaration:${kind}:${blockHoist}`;
+ let declarPath = !unique && path.getData(dataKey);
+
+ if (!declarPath) {
+ const declar = variableDeclaration(kind, []);
+ declar._blockHoist = blockHoist;
+ [declarPath] = path.unshiftContainer("body", [declar]);
+ if (!unique) path.setData(dataKey, declarPath);
+ }
+
+ const declarator = variableDeclarator(opts.id, opts.init);
+ const len = declarPath.node.declarations.push(declarator);
+ path.scope.registerBinding(kind, declarPath.get("declarations")[len - 1]);
+ }
+
+ getProgramParent() {
+ let scope = this;
+
+ do {
+ if (scope.path.isProgram()) {
+ return scope;
+ }
+ } while (scope = scope.parent);
+
+ throw new Error("Couldn't find a Program");
+ }
+
+ getFunctionParent() {
+ let scope = this;
+
+ do {
+ if (scope.path.isFunctionParent()) {
+ return scope;
+ }
+ } while (scope = scope.parent);
+
+ return null;
+ }
+
+ getBlockParent() {
+ let scope = this;
+
+ do {
+ if (scope.path.isBlockParent()) {
+ return scope;
+ }
+ } while (scope = scope.parent);
+
+ throw new Error("We couldn't find a BlockStatement, For, Switch, Function, Loop or Program...");
+ }
+
+ getAllBindings() {
+ const ids = Object.create(null);
+ let scope = this;
+
+ do {
+ for (const key of Object.keys(scope.bindings)) {
+ if (key in ids === false) {
+ ids[key] = scope.bindings[key];
+ }
+ }
+
+ scope = scope.parent;
+ } while (scope);
+
+ return ids;
+ }
+
+ getAllBindingsOfKind(...kinds) {
+ const ids = Object.create(null);
+
+ for (const kind of kinds) {
+ let scope = this;
+
+ do {
+ for (const name of Object.keys(scope.bindings)) {
+ const binding = scope.bindings[name];
+ if (binding.kind === kind) ids[name] = binding;
+ }
+
+ scope = scope.parent;
+ } while (scope);
+ }
+
+ return ids;
+ }
+
+ bindingIdentifierEquals(name, node) {
+ return this.getBindingIdentifier(name) === node;
+ }
+
+ getBinding(name) {
+ let scope = this;
+ let previousPath;
+
+ do {
+ const binding = scope.getOwnBinding(name);
+
+ if (binding) {
+ var _previousPath;
+
+ if ((_previousPath = previousPath) != null && _previousPath.isPattern() && binding.kind !== "param" && binding.kind !== "local") {} else {
+ return binding;
+ }
+ } else if (!binding && name === "arguments" && scope.path.isFunction() && !scope.path.isArrowFunctionExpression()) {
+ break;
+ }
+
+ previousPath = scope.path;
+ } while (scope = scope.parent);
+ }
+
+ getOwnBinding(name) {
+ return this.bindings[name];
+ }
+
+ getBindingIdentifier(name) {
+ var _this$getBinding;
+
+ return (_this$getBinding = this.getBinding(name)) == null ? void 0 : _this$getBinding.identifier;
+ }
+
+ getOwnBindingIdentifier(name) {
+ const binding = this.bindings[name];
+ return binding == null ? void 0 : binding.identifier;
+ }
+
+ hasOwnBinding(name) {
+ return !!this.getOwnBinding(name);
+ }
+
+ hasBinding(name, noGlobals) {
+ if (!name) return false;
+ if (this.hasOwnBinding(name)) return true;
+ if (this.parentHasBinding(name, noGlobals)) return true;
+ if (this.hasUid(name)) return true;
+ if (!noGlobals && Scope.globals.includes(name)) return true;
+ if (!noGlobals && Scope.contextVariables.includes(name)) return true;
+ return false;
+ }
+
+ parentHasBinding(name, noGlobals) {
+ var _this$parent;
+
+ return (_this$parent = this.parent) == null ? void 0 : _this$parent.hasBinding(name, noGlobals);
+ }
+
+ moveBindingTo(name, scope) {
+ const info = this.getBinding(name);
+
+ if (info) {
+ info.scope.removeOwnBinding(name);
+ info.scope = scope;
+ scope.bindings[name] = info;
+ }
+ }
+
+ removeOwnBinding(name) {
+ delete this.bindings[name];
+ }
+
+ removeBinding(name) {
+ var _this$getBinding2;
+
+ (_this$getBinding2 = this.getBinding(name)) == null ? void 0 : _this$getBinding2.scope.removeOwnBinding(name);
+ let scope = this;
+
+ do {
+ if (scope.uids[name]) {
+ scope.uids[name] = false;
+ }
+ } while (scope = scope.parent);
+ }
+
+}
+
+exports.default = Scope;
+Scope.globals = Object.keys(_globals.builtin);
+Scope.contextVariables = ["arguments", "undefined", "Infinity", "NaN"];
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/lib/scope/lib/renamer.js b/node_modules/@babel/traverse/lib/scope/lib/renamer.js
new file mode 100644
index 000000000..f11bbb700
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/scope/lib/renamer.js
@@ -0,0 +1,146 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = void 0;
+
+var _binding = require("../binding");
+
+var _helperSplitExportDeclaration = require("@babel/helper-split-export-declaration");
+
+var _t = require("@babel/types");
+
+const {
+ VISITOR_KEYS,
+ assignmentExpression,
+ identifier,
+ toExpression,
+ variableDeclaration,
+ variableDeclarator
+} = _t;
+const renameVisitor = {
+ ReferencedIdentifier({
+ node
+ }, state) {
+ if (node.name === state.oldName) {
+ node.name = state.newName;
+ }
+ },
+
+ Scope(path, state) {
+ if (!path.scope.bindingIdentifierEquals(state.oldName, state.binding.identifier)) {
+ skipAllButComputedMethodKey(path);
+ }
+ },
+
+ "AssignmentExpression|Declaration|VariableDeclarator"(path, state) {
+ if (path.isVariableDeclaration()) return;
+ const ids = path.getOuterBindingIdentifiers();
+
+ for (const name in ids) {
+ if (name === state.oldName) ids[name].name = state.newName;
+ }
+ }
+
+};
+
+class Renamer {
+ constructor(binding, oldName, newName) {
+ this.newName = newName;
+ this.oldName = oldName;
+ this.binding = binding;
+ }
+
+ maybeConvertFromExportDeclaration(parentDeclar) {
+ const maybeExportDeclar = parentDeclar.parentPath;
+
+ if (!maybeExportDeclar.isExportDeclaration()) {
+ return;
+ }
+
+ if (maybeExportDeclar.isExportDefaultDeclaration() && !maybeExportDeclar.get("declaration").node.id) {
+ return;
+ }
+
+ (0, _helperSplitExportDeclaration.default)(maybeExportDeclar);
+ }
+
+ maybeConvertFromClassFunctionDeclaration(path) {
+ return;
+ if (!path.isFunctionDeclaration() && !path.isClassDeclaration()) return;
+ if (this.binding.kind !== "hoisted") return;
+ path.node.id = identifier(this.oldName);
+ path.node._blockHoist = 3;
+ path.replaceWith(variableDeclaration("let", [variableDeclarator(identifier(this.newName), toExpression(path.node))]));
+ }
+
+ maybeConvertFromClassFunctionExpression(path) {
+ return;
+ if (!path.isFunctionExpression() && !path.isClassExpression()) return;
+ if (this.binding.kind !== "local") return;
+ path.node.id = identifier(this.oldName);
+ this.binding.scope.parent.push({
+ id: identifier(this.newName)
+ });
+ path.replaceWith(assignmentExpression("=", identifier(this.newName), path.node));
+ }
+
+ rename(block) {
+ const {
+ binding,
+ oldName,
+ newName
+ } = this;
+ const {
+ scope,
+ path
+ } = binding;
+ const parentDeclar = path.find(path => path.isDeclaration() || path.isFunctionExpression() || path.isClassExpression());
+
+ if (parentDeclar) {
+ const bindingIds = parentDeclar.getOuterBindingIdentifiers();
+
+ if (bindingIds[oldName] === binding.identifier) {
+ this.maybeConvertFromExportDeclaration(parentDeclar);
+ }
+ }
+
+ const blockToTraverse = block || scope.block;
+
+ if ((blockToTraverse == null ? void 0 : blockToTraverse.type) === "SwitchStatement") {
+ blockToTraverse.cases.forEach(c => {
+ scope.traverse(c, renameVisitor, this);
+ });
+ } else {
+ scope.traverse(blockToTraverse, renameVisitor, this);
+ }
+
+ if (!block) {
+ scope.removeOwnBinding(oldName);
+ scope.bindings[newName] = binding;
+ this.binding.identifier.name = newName;
+ }
+
+ if (parentDeclar) {
+ this.maybeConvertFromClassFunctionDeclaration(parentDeclar);
+ this.maybeConvertFromClassFunctionExpression(parentDeclar);
+ }
+ }
+
+}
+
+exports.default = Renamer;
+
+function skipAllButComputedMethodKey(path) {
+ if (!path.isMethod() || !path.node.computed) {
+ path.skip();
+ return;
+ }
+
+ const keys = VISITOR_KEYS[path.type];
+
+ for (const key of keys) {
+ if (key !== "key") path.skipKey(key);
+ }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/lib/traverse-node.js b/node_modules/@babel/traverse/lib/traverse-node.js
new file mode 100644
index 000000000..82437b461
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/traverse-node.js
@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.traverseNode = traverseNode;
+
+var _context = require("./context");
+
+var _t = require("@babel/types");
+
+const {
+ VISITOR_KEYS
+} = _t;
+
+function traverseNode(node, opts, scope, state, path, skipKeys) {
+ const keys = VISITOR_KEYS[node.type];
+ if (!keys) return false;
+ const context = new _context.default(scope, opts, state, path);
+
+ for (const key of keys) {
+ if (skipKeys && skipKeys[key]) continue;
+
+ if (context.visit(node, key)) {
+ return true;
+ }
+ }
+
+ return false;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/lib/types.js b/node_modules/@babel/traverse/lib/types.js
new file mode 100644
index 000000000..ec17ee62f
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/types.js
@@ -0,0 +1,5 @@
+"use strict";
+
+var _index = require("./index");
+
+var _virtualTypes = require("./path/generated/virtual-types");
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/lib/visitors.js b/node_modules/@babel/traverse/lib/visitors.js
new file mode 100644
index 000000000..81d633577
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/visitors.js
@@ -0,0 +1,242 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.explode = explode;
+exports.merge = merge;
+exports.verify = verify;
+
+var virtualTypes = require("./path/lib/virtual-types");
+
+var _t = require("@babel/types");
+
+const {
+ DEPRECATED_KEYS,
+ FLIPPED_ALIAS_KEYS,
+ TYPES
+} = _t;
+
+function explode(visitor) {
+ if (visitor._exploded) return visitor;
+ visitor._exploded = true;
+
+ for (const nodeType of Object.keys(visitor)) {
+ if (shouldIgnoreKey(nodeType)) continue;
+ const parts = nodeType.split("|");
+ if (parts.length === 1) continue;
+ const fns = visitor[nodeType];
+ delete visitor[nodeType];
+
+ for (const part of parts) {
+ visitor[part] = fns;
+ }
+ }
+
+ verify(visitor);
+ delete visitor.__esModule;
+ ensureEntranceObjects(visitor);
+ ensureCallbackArrays(visitor);
+
+ for (const nodeType of Object.keys(visitor)) {
+ if (shouldIgnoreKey(nodeType)) continue;
+ const wrapper = virtualTypes[nodeType];
+ if (!wrapper) continue;
+ const fns = visitor[nodeType];
+
+ for (const type of Object.keys(fns)) {
+ fns[type] = wrapCheck(wrapper, fns[type]);
+ }
+
+ delete visitor[nodeType];
+
+ if (wrapper.types) {
+ for (const type of wrapper.types) {
+ if (visitor[type]) {
+ mergePair(visitor[type], fns);
+ } else {
+ visitor[type] = fns;
+ }
+ }
+ } else {
+ mergePair(visitor, fns);
+ }
+ }
+
+ for (const nodeType of Object.keys(visitor)) {
+ if (shouldIgnoreKey(nodeType)) continue;
+ const fns = visitor[nodeType];
+ let aliases = FLIPPED_ALIAS_KEYS[nodeType];
+ const deprecatedKey = DEPRECATED_KEYS[nodeType];
+
+ if (deprecatedKey) {
+ console.trace(`Visitor defined for ${nodeType} but it has been renamed to ${deprecatedKey}`);
+ aliases = [deprecatedKey];
+ }
+
+ if (!aliases) continue;
+ delete visitor[nodeType];
+
+ for (const alias of aliases) {
+ const existing = visitor[alias];
+
+ if (existing) {
+ mergePair(existing, fns);
+ } else {
+ visitor[alias] = Object.assign({}, fns);
+ }
+ }
+ }
+
+ for (const nodeType of Object.keys(visitor)) {
+ if (shouldIgnoreKey(nodeType)) continue;
+ ensureCallbackArrays(visitor[nodeType]);
+ }
+
+ return visitor;
+}
+
+function verify(visitor) {
+ if (visitor._verified) return;
+
+ if (typeof visitor === "function") {
+ throw new Error("You passed `traverse()` a function when it expected a visitor object, " + "are you sure you didn't mean `{ enter: Function }`?");
+ }
+
+ for (const nodeType of Object.keys(visitor)) {
+ if (nodeType === "enter" || nodeType === "exit") {
+ validateVisitorMethods(nodeType, visitor[nodeType]);
+ }
+
+ if (shouldIgnoreKey(nodeType)) continue;
+
+ if (TYPES.indexOf(nodeType) < 0) {
+ throw new Error(`You gave us a visitor for the node type ${nodeType} but it's not a valid type`);
+ }
+
+ const visitors = visitor[nodeType];
+
+ if (typeof visitors === "object") {
+ for (const visitorKey of Object.keys(visitors)) {
+ if (visitorKey === "enter" || visitorKey === "exit") {
+ validateVisitorMethods(`${nodeType}.${visitorKey}`, visitors[visitorKey]);
+ } else {
+ throw new Error("You passed `traverse()` a visitor object with the property " + `${nodeType} that has the invalid property ${visitorKey}`);
+ }
+ }
+ }
+ }
+
+ visitor._verified = true;
+}
+
+function validateVisitorMethods(path, val) {
+ const fns = [].concat(val);
+
+ for (const fn of fns) {
+ if (typeof fn !== "function") {
+ throw new TypeError(`Non-function found defined in ${path} with type ${typeof fn}`);
+ }
+ }
+}
+
+function merge(visitors, states = [], wrapper) {
+ const rootVisitor = {};
+
+ for (let i = 0; i < visitors.length; i++) {
+ const visitor = visitors[i];
+ const state = states[i];
+ explode(visitor);
+
+ for (const type of Object.keys(visitor)) {
+ let visitorType = visitor[type];
+
+ if (state || wrapper) {
+ visitorType = wrapWithStateOrWrapper(visitorType, state, wrapper);
+ }
+
+ const nodeVisitor = rootVisitor[type] = rootVisitor[type] || {};
+ mergePair(nodeVisitor, visitorType);
+ }
+ }
+
+ return rootVisitor;
+}
+
+function wrapWithStateOrWrapper(oldVisitor, state, wrapper) {
+ const newVisitor = {};
+
+ for (const key of Object.keys(oldVisitor)) {
+ let fns = oldVisitor[key];
+ if (!Array.isArray(fns)) continue;
+ fns = fns.map(function (fn) {
+ let newFn = fn;
+
+ if (state) {
+ newFn = function (path) {
+ return fn.call(state, path, state);
+ };
+ }
+
+ if (wrapper) {
+ newFn = wrapper(state.key, key, newFn);
+ }
+
+ if (newFn !== fn) {
+ newFn.toString = () => fn.toString();
+ }
+
+ return newFn;
+ });
+ newVisitor[key] = fns;
+ }
+
+ return newVisitor;
+}
+
+function ensureEntranceObjects(obj) {
+ for (const key of Object.keys(obj)) {
+ if (shouldIgnoreKey(key)) continue;
+ const fns = obj[key];
+
+ if (typeof fns === "function") {
+ obj[key] = {
+ enter: fns
+ };
+ }
+ }
+}
+
+function ensureCallbackArrays(obj) {
+ if (obj.enter && !Array.isArray(obj.enter)) obj.enter = [obj.enter];
+ if (obj.exit && !Array.isArray(obj.exit)) obj.exit = [obj.exit];
+}
+
+function wrapCheck(wrapper, fn) {
+ const newFn = function (path) {
+ if (wrapper.checkPath(path)) {
+ return fn.apply(this, arguments);
+ }
+ };
+
+ newFn.toString = () => fn.toString();
+
+ return newFn;
+}
+
+function shouldIgnoreKey(key) {
+ if (key[0] === "_") return true;
+ if (key === "enter" || key === "exit" || key === "shouldSkip") return true;
+
+ if (key === "denylist" || key === "noScope" || key === "skipKeys" || key === "blacklist") {
+ return true;
+ }
+
+ return false;
+}
+
+function mergePair(dest, src) {
+ for (const key of Object.keys(src)) {
+ dest[key] = [].concat(dest[key] || [], src[key]);
+ }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/package.json b/node_modules/@babel/traverse/package.json
new file mode 100644
index 000000000..401ba2511
--- /dev/null
+++ b/node_modules/@babel/traverse/package.json
@@ -0,0 +1,36 @@
+{
+ "name": "@babel/traverse",
+ "version": "7.17.3",
+ "description": "The Babel Traverse module maintains the overall tree state, and is responsible for replacing, removing, and adding nodes",
+ "author": "The Babel Team (https://babel.dev/team)",
+ "homepage": "https://babel.dev/docs/en/next/babel-traverse",
+ "bugs": "https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20traverse%22+is%3Aopen",
+ "license": "MIT",
+ "publishConfig": {
+ "access": "public"
+ },
+ "repository": {
+ "type": "git",
+ "url": "https://github.com/babel/babel.git",
+ "directory": "packages/babel-traverse"
+ },
+ "main": "./lib/index.js",
+ "dependencies": {
+ "@babel/code-frame": "^7.16.7",
+ "@babel/generator": "^7.17.3",
+ "@babel/helper-environment-visitor": "^7.16.7",
+ "@babel/helper-function-name": "^7.16.7",
+ "@babel/helper-hoist-variables": "^7.16.7",
+ "@babel/helper-split-export-declaration": "^7.16.7",
+ "@babel/parser": "^7.17.3",
+ "@babel/types": "^7.17.0",
+ "debug": "^4.1.0",
+ "globals": "^11.1.0"
+ },
+ "devDependencies": {
+ "@babel/helper-plugin-test-runner": "^7.16.7"
+ },
+ "engines": {
+ "node": ">=6.9.0"
+ }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/scripts/generators/asserts.js b/node_modules/@babel/traverse/scripts/generators/asserts.js
new file mode 100644
index 000000000..f10b33eed
--- /dev/null
+++ b/node_modules/@babel/traverse/scripts/generators/asserts.js
@@ -0,0 +1,25 @@
+import t from "@babel/types";
+
+export default function generateAsserts() {
+ let output = `/*
+ * This file is auto-generated! Do not modify it directly.
+ * To re-generate run 'make build'
+ */
+import * as t from "@babel/types";
+import NodePath from "../index";
+
+
+export interface NodePathAssetions {`;
+
+ for (const type of [...t.TYPES].sort()) {
+ output += `
+ assert${type}(
+ opts?: object,
+ ): asserts this is NodePath;`;
+ }
+
+ output += `
+}`;
+
+ return output;
+}
diff --git a/node_modules/@babel/traverse/scripts/generators/validators.js b/node_modules/@babel/traverse/scripts/generators/validators.js
new file mode 100644
index 000000000..f806fc76c
--- /dev/null
+++ b/node_modules/@babel/traverse/scripts/generators/validators.js
@@ -0,0 +1,42 @@
+import t from "@babel/types";
+import virtualTypes from "../../lib/path/lib/virtual-types.js";
+
+export default function generateValidators() {
+ let output = `/*
+ * This file is auto-generated! Do not modify it directly.
+ * To re-generate run 'make build'
+ */
+import * as t from "@babel/types";
+import NodePath from "../index";
+import type { VirtualTypeAliases } from "./virtual-types";
+
+export interface NodePathValidators {
+`;
+
+ for (const type of [...t.TYPES].sort()) {
+ output += `is${type}(opts?: object): this is NodePath;`;
+ }
+
+ for (const type of Object.keys(virtualTypes)) {
+ const { types } = virtualTypes[type];
+ if (type[0] === "_") continue;
+ if (t.NODE_FIELDS[type] || t.FLIPPED_ALIAS_KEYS[type]) {
+ output += `is${type}(opts?: object): this is NodePath;`;
+ } else if (types /* in VirtualTypeAliases */) {
+ output += `is${type}(opts?: object): this is NodePath;`;
+ } else {
+ // if it don't have types, then VirtualTypeAliases[type] is t.Node
+ // which TS marked as always true
+ // eg. if (path.isBlockScope()) return;
+ // path resolved to `never` here
+ // so we have to return boolean instead of this is NodePath here
+ output += `is${type}(opts?: object): boolean;`;
+ }
+ }
+
+ output += `
+}
+`;
+
+ return output;
+}
diff --git a/node_modules/@babel/traverse/scripts/generators/virtual-types.js b/node_modules/@babel/traverse/scripts/generators/virtual-types.js
new file mode 100644
index 000000000..6d55f54ca
--- /dev/null
+++ b/node_modules/@babel/traverse/scripts/generators/virtual-types.js
@@ -0,0 +1,24 @@
+import virtualTypes from "../../lib/path/lib/virtual-types.js";
+
+export default function generateValidators() {
+ let output = `/*
+ * This file is auto-generated! Do not modify it directly.
+ * To re-generate run 'make build'
+ */
+import * as t from "@babel/types";
+
+export interface VirtualTypeAliases {
+`;
+
+ for (const type of Object.keys(virtualTypes)) {
+ output += ` ${type}: ${(virtualTypes[type].types || ["Node"])
+ .map(t => `t.${t}`)
+ .join(" | ")};`;
+ }
+
+ output += `
+}
+`;
+
+ return output;
+}
diff --git a/node_modules/@babel/traverse/scripts/package.json b/node_modules/@babel/traverse/scripts/package.json
new file mode 100644
index 000000000..5ffd9800b
--- /dev/null
+++ b/node_modules/@babel/traverse/scripts/package.json
@@ -0,0 +1 @@
+{ "type": "module" }
diff --git a/node_modules/@babel/types/LICENSE b/node_modules/@babel/types/LICENSE
new file mode 100644
index 000000000..f31575ec7
--- /dev/null
+++ b/node_modules/@babel/types/LICENSE
@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/node_modules/@babel/types/README.md b/node_modules/@babel/types/README.md
new file mode 100644
index 000000000..0071bd7a9
--- /dev/null
+++ b/node_modules/@babel/types/README.md
@@ -0,0 +1,19 @@
+# @babel/types
+
+> Babel Types is a Lodash-esque utility library for AST nodes
+
+See our website [@babel/types](https://babeljs.io/docs/en/babel-types) for more information or the [issues](https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20types%22+is%3Aopen) associated with this package.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save-dev @babel/types
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/types --dev
+```
diff --git a/node_modules/@babel/types/lib/asserts/assertNode.js b/node_modules/@babel/types/lib/asserts/assertNode.js
new file mode 100644
index 000000000..e584e3eec
--- /dev/null
+++ b/node_modules/@babel/types/lib/asserts/assertNode.js
@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = assertNode;
+
+var _isNode = require("../validators/isNode");
+
+function assertNode(node) {
+ if (!(0, _isNode.default)(node)) {
+ var _node$type;
+
+ const type = (_node$type = node == null ? void 0 : node.type) != null ? _node$type : JSON.stringify(node);
+ throw new TypeError(`Not a valid node of type "${type}"`);
+ }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/asserts/generated/index.js b/node_modules/@babel/types/lib/asserts/generated/index.js
new file mode 100644
index 000000000..53a55168d
--- /dev/null
+++ b/node_modules/@babel/types/lib/asserts/generated/index.js
@@ -0,0 +1,1517 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.assertAccessor = assertAccessor;
+exports.assertAnyTypeAnnotation = assertAnyTypeAnnotation;
+exports.assertArgumentPlaceholder = assertArgumentPlaceholder;
+exports.assertArrayExpression = assertArrayExpression;
+exports.assertArrayPattern = assertArrayPattern;
+exports.assertArrayTypeAnnotation = assertArrayTypeAnnotation;
+exports.assertArrowFunctionExpression = assertArrowFunctionExpression;
+exports.assertAssignmentExpression = assertAssignmentExpression;
+exports.assertAssignmentPattern = assertAssignmentPattern;
+exports.assertAwaitExpression = assertAwaitExpression;
+exports.assertBigIntLiteral = assertBigIntLiteral;
+exports.assertBinary = assertBinary;
+exports.assertBinaryExpression = assertBinaryExpression;
+exports.assertBindExpression = assertBindExpression;
+exports.assertBlock = assertBlock;
+exports.assertBlockParent = assertBlockParent;
+exports.assertBlockStatement = assertBlockStatement;
+exports.assertBooleanLiteral = assertBooleanLiteral;
+exports.assertBooleanLiteralTypeAnnotation = assertBooleanLiteralTypeAnnotation;
+exports.assertBooleanTypeAnnotation = assertBooleanTypeAnnotation;
+exports.assertBreakStatement = assertBreakStatement;
+exports.assertCallExpression = assertCallExpression;
+exports.assertCatchClause = assertCatchClause;
+exports.assertClass = assertClass;
+exports.assertClassAccessorProperty = assertClassAccessorProperty;
+exports.assertClassBody = assertClassBody;
+exports.assertClassDeclaration = assertClassDeclaration;
+exports.assertClassExpression = assertClassExpression;
+exports.assertClassImplements = assertClassImplements;
+exports.assertClassMethod = assertClassMethod;
+exports.assertClassPrivateMethod = assertClassPrivateMethod;
+exports.assertClassPrivateProperty = assertClassPrivateProperty;
+exports.assertClassProperty = assertClassProperty;
+exports.assertCompletionStatement = assertCompletionStatement;
+exports.assertConditional = assertConditional;
+exports.assertConditionalExpression = assertConditionalExpression;
+exports.assertContinueStatement = assertContinueStatement;
+exports.assertDebuggerStatement = assertDebuggerStatement;
+exports.assertDecimalLiteral = assertDecimalLiteral;
+exports.assertDeclaration = assertDeclaration;
+exports.assertDeclareClass = assertDeclareClass;
+exports.assertDeclareExportAllDeclaration = assertDeclareExportAllDeclaration;
+exports.assertDeclareExportDeclaration = assertDeclareExportDeclaration;
+exports.assertDeclareFunction = assertDeclareFunction;
+exports.assertDeclareInterface = assertDeclareInterface;
+exports.assertDeclareModule = assertDeclareModule;
+exports.assertDeclareModuleExports = assertDeclareModuleExports;
+exports.assertDeclareOpaqueType = assertDeclareOpaqueType;
+exports.assertDeclareTypeAlias = assertDeclareTypeAlias;
+exports.assertDeclareVariable = assertDeclareVariable;
+exports.assertDeclaredPredicate = assertDeclaredPredicate;
+exports.assertDecorator = assertDecorator;
+exports.assertDirective = assertDirective;
+exports.assertDirectiveLiteral = assertDirectiveLiteral;
+exports.assertDoExpression = assertDoExpression;
+exports.assertDoWhileStatement = assertDoWhileStatement;
+exports.assertEmptyStatement = assertEmptyStatement;
+exports.assertEmptyTypeAnnotation = assertEmptyTypeAnnotation;
+exports.assertEnumBody = assertEnumBody;
+exports.assertEnumBooleanBody = assertEnumBooleanBody;
+exports.assertEnumBooleanMember = assertEnumBooleanMember;
+exports.assertEnumDeclaration = assertEnumDeclaration;
+exports.assertEnumDefaultedMember = assertEnumDefaultedMember;
+exports.assertEnumMember = assertEnumMember;
+exports.assertEnumNumberBody = assertEnumNumberBody;
+exports.assertEnumNumberMember = assertEnumNumberMember;
+exports.assertEnumStringBody = assertEnumStringBody;
+exports.assertEnumStringMember = assertEnumStringMember;
+exports.assertEnumSymbolBody = assertEnumSymbolBody;
+exports.assertExistsTypeAnnotation = assertExistsTypeAnnotation;
+exports.assertExportAllDeclaration = assertExportAllDeclaration;
+exports.assertExportDeclaration = assertExportDeclaration;
+exports.assertExportDefaultDeclaration = assertExportDefaultDeclaration;
+exports.assertExportDefaultSpecifier = assertExportDefaultSpecifier;
+exports.assertExportNamedDeclaration = assertExportNamedDeclaration;
+exports.assertExportNamespaceSpecifier = assertExportNamespaceSpecifier;
+exports.assertExportSpecifier = assertExportSpecifier;
+exports.assertExpression = assertExpression;
+exports.assertExpressionStatement = assertExpressionStatement;
+exports.assertExpressionWrapper = assertExpressionWrapper;
+exports.assertFile = assertFile;
+exports.assertFlow = assertFlow;
+exports.assertFlowBaseAnnotation = assertFlowBaseAnnotation;
+exports.assertFlowDeclaration = assertFlowDeclaration;
+exports.assertFlowPredicate = assertFlowPredicate;
+exports.assertFlowType = assertFlowType;
+exports.assertFor = assertFor;
+exports.assertForInStatement = assertForInStatement;
+exports.assertForOfStatement = assertForOfStatement;
+exports.assertForStatement = assertForStatement;
+exports.assertForXStatement = assertForXStatement;
+exports.assertFunction = assertFunction;
+exports.assertFunctionDeclaration = assertFunctionDeclaration;
+exports.assertFunctionExpression = assertFunctionExpression;
+exports.assertFunctionParent = assertFunctionParent;
+exports.assertFunctionTypeAnnotation = assertFunctionTypeAnnotation;
+exports.assertFunctionTypeParam = assertFunctionTypeParam;
+exports.assertGenericTypeAnnotation = assertGenericTypeAnnotation;
+exports.assertIdentifier = assertIdentifier;
+exports.assertIfStatement = assertIfStatement;
+exports.assertImmutable = assertImmutable;
+exports.assertImport = assertImport;
+exports.assertImportAttribute = assertImportAttribute;
+exports.assertImportDeclaration = assertImportDeclaration;
+exports.assertImportDefaultSpecifier = assertImportDefaultSpecifier;
+exports.assertImportNamespaceSpecifier = assertImportNamespaceSpecifier;
+exports.assertImportSpecifier = assertImportSpecifier;
+exports.assertIndexedAccessType = assertIndexedAccessType;
+exports.assertInferredPredicate = assertInferredPredicate;
+exports.assertInterfaceDeclaration = assertInterfaceDeclaration;
+exports.assertInterfaceExtends = assertInterfaceExtends;
+exports.assertInterfaceTypeAnnotation = assertInterfaceTypeAnnotation;
+exports.assertInterpreterDirective = assertInterpreterDirective;
+exports.assertIntersectionTypeAnnotation = assertIntersectionTypeAnnotation;
+exports.assertJSX = assertJSX;
+exports.assertJSXAttribute = assertJSXAttribute;
+exports.assertJSXClosingElement = assertJSXClosingElement;
+exports.assertJSXClosingFragment = assertJSXClosingFragment;
+exports.assertJSXElement = assertJSXElement;
+exports.assertJSXEmptyExpression = assertJSXEmptyExpression;
+exports.assertJSXExpressionContainer = assertJSXExpressionContainer;
+exports.assertJSXFragment = assertJSXFragment;
+exports.assertJSXIdentifier = assertJSXIdentifier;
+exports.assertJSXMemberExpression = assertJSXMemberExpression;
+exports.assertJSXNamespacedName = assertJSXNamespacedName;
+exports.assertJSXOpeningElement = assertJSXOpeningElement;
+exports.assertJSXOpeningFragment = assertJSXOpeningFragment;
+exports.assertJSXSpreadAttribute = assertJSXSpreadAttribute;
+exports.assertJSXSpreadChild = assertJSXSpreadChild;
+exports.assertJSXText = assertJSXText;
+exports.assertLVal = assertLVal;
+exports.assertLabeledStatement = assertLabeledStatement;
+exports.assertLiteral = assertLiteral;
+exports.assertLogicalExpression = assertLogicalExpression;
+exports.assertLoop = assertLoop;
+exports.assertMemberExpression = assertMemberExpression;
+exports.assertMetaProperty = assertMetaProperty;
+exports.assertMethod = assertMethod;
+exports.assertMiscellaneous = assertMiscellaneous;
+exports.assertMixedTypeAnnotation = assertMixedTypeAnnotation;
+exports.assertModuleDeclaration = assertModuleDeclaration;
+exports.assertModuleExpression = assertModuleExpression;
+exports.assertModuleSpecifier = assertModuleSpecifier;
+exports.assertNewExpression = assertNewExpression;
+exports.assertNoop = assertNoop;
+exports.assertNullLiteral = assertNullLiteral;
+exports.assertNullLiteralTypeAnnotation = assertNullLiteralTypeAnnotation;
+exports.assertNullableTypeAnnotation = assertNullableTypeAnnotation;
+exports.assertNumberLiteral = assertNumberLiteral;
+exports.assertNumberLiteralTypeAnnotation = assertNumberLiteralTypeAnnotation;
+exports.assertNumberTypeAnnotation = assertNumberTypeAnnotation;
+exports.assertNumericLiteral = assertNumericLiteral;
+exports.assertObjectExpression = assertObjectExpression;
+exports.assertObjectMember = assertObjectMember;
+exports.assertObjectMethod = assertObjectMethod;
+exports.assertObjectPattern = assertObjectPattern;
+exports.assertObjectProperty = assertObjectProperty;
+exports.assertObjectTypeAnnotation = assertObjectTypeAnnotation;
+exports.assertObjectTypeCallProperty = assertObjectTypeCallProperty;
+exports.assertObjectTypeIndexer = assertObjectTypeIndexer;
+exports.assertObjectTypeInternalSlot = assertObjectTypeInternalSlot;
+exports.assertObjectTypeProperty = assertObjectTypeProperty;
+exports.assertObjectTypeSpreadProperty = assertObjectTypeSpreadProperty;
+exports.assertOpaqueType = assertOpaqueType;
+exports.assertOptionalCallExpression = assertOptionalCallExpression;
+exports.assertOptionalIndexedAccessType = assertOptionalIndexedAccessType;
+exports.assertOptionalMemberExpression = assertOptionalMemberExpression;
+exports.assertParenthesizedExpression = assertParenthesizedExpression;
+exports.assertPattern = assertPattern;
+exports.assertPatternLike = assertPatternLike;
+exports.assertPipelineBareFunction = assertPipelineBareFunction;
+exports.assertPipelinePrimaryTopicReference = assertPipelinePrimaryTopicReference;
+exports.assertPipelineTopicExpression = assertPipelineTopicExpression;
+exports.assertPlaceholder = assertPlaceholder;
+exports.assertPrivate = assertPrivate;
+exports.assertPrivateName = assertPrivateName;
+exports.assertProgram = assertProgram;
+exports.assertProperty = assertProperty;
+exports.assertPureish = assertPureish;
+exports.assertQualifiedTypeIdentifier = assertQualifiedTypeIdentifier;
+exports.assertRecordExpression = assertRecordExpression;
+exports.assertRegExpLiteral = assertRegExpLiteral;
+exports.assertRegexLiteral = assertRegexLiteral;
+exports.assertRestElement = assertRestElement;
+exports.assertRestProperty = assertRestProperty;
+exports.assertReturnStatement = assertReturnStatement;
+exports.assertScopable = assertScopable;
+exports.assertSequenceExpression = assertSequenceExpression;
+exports.assertSpreadElement = assertSpreadElement;
+exports.assertSpreadProperty = assertSpreadProperty;
+exports.assertStandardized = assertStandardized;
+exports.assertStatement = assertStatement;
+exports.assertStaticBlock = assertStaticBlock;
+exports.assertStringLiteral = assertStringLiteral;
+exports.assertStringLiteralTypeAnnotation = assertStringLiteralTypeAnnotation;
+exports.assertStringTypeAnnotation = assertStringTypeAnnotation;
+exports.assertSuper = assertSuper;
+exports.assertSwitchCase = assertSwitchCase;
+exports.assertSwitchStatement = assertSwitchStatement;
+exports.assertSymbolTypeAnnotation = assertSymbolTypeAnnotation;
+exports.assertTSAnyKeyword = assertTSAnyKeyword;
+exports.assertTSArrayType = assertTSArrayType;
+exports.assertTSAsExpression = assertTSAsExpression;
+exports.assertTSBaseType = assertTSBaseType;
+exports.assertTSBigIntKeyword = assertTSBigIntKeyword;
+exports.assertTSBooleanKeyword = assertTSBooleanKeyword;
+exports.assertTSCallSignatureDeclaration = assertTSCallSignatureDeclaration;
+exports.assertTSConditionalType = assertTSConditionalType;
+exports.assertTSConstructSignatureDeclaration = assertTSConstructSignatureDeclaration;
+exports.assertTSConstructorType = assertTSConstructorType;
+exports.assertTSDeclareFunction = assertTSDeclareFunction;
+exports.assertTSDeclareMethod = assertTSDeclareMethod;
+exports.assertTSEntityName = assertTSEntityName;
+exports.assertTSEnumDeclaration = assertTSEnumDeclaration;
+exports.assertTSEnumMember = assertTSEnumMember;
+exports.assertTSExportAssignment = assertTSExportAssignment;
+exports.assertTSExpressionWithTypeArguments = assertTSExpressionWithTypeArguments;
+exports.assertTSExternalModuleReference = assertTSExternalModuleReference;
+exports.assertTSFunctionType = assertTSFunctionType;
+exports.assertTSImportEqualsDeclaration = assertTSImportEqualsDeclaration;
+exports.assertTSImportType = assertTSImportType;
+exports.assertTSIndexSignature = assertTSIndexSignature;
+exports.assertTSIndexedAccessType = assertTSIndexedAccessType;
+exports.assertTSInferType = assertTSInferType;
+exports.assertTSInterfaceBody = assertTSInterfaceBody;
+exports.assertTSInterfaceDeclaration = assertTSInterfaceDeclaration;
+exports.assertTSIntersectionType = assertTSIntersectionType;
+exports.assertTSIntrinsicKeyword = assertTSIntrinsicKeyword;
+exports.assertTSLiteralType = assertTSLiteralType;
+exports.assertTSMappedType = assertTSMappedType;
+exports.assertTSMethodSignature = assertTSMethodSignature;
+exports.assertTSModuleBlock = assertTSModuleBlock;
+exports.assertTSModuleDeclaration = assertTSModuleDeclaration;
+exports.assertTSNamedTupleMember = assertTSNamedTupleMember;
+exports.assertTSNamespaceExportDeclaration = assertTSNamespaceExportDeclaration;
+exports.assertTSNeverKeyword = assertTSNeverKeyword;
+exports.assertTSNonNullExpression = assertTSNonNullExpression;
+exports.assertTSNullKeyword = assertTSNullKeyword;
+exports.assertTSNumberKeyword = assertTSNumberKeyword;
+exports.assertTSObjectKeyword = assertTSObjectKeyword;
+exports.assertTSOptionalType = assertTSOptionalType;
+exports.assertTSParameterProperty = assertTSParameterProperty;
+exports.assertTSParenthesizedType = assertTSParenthesizedType;
+exports.assertTSPropertySignature = assertTSPropertySignature;
+exports.assertTSQualifiedName = assertTSQualifiedName;
+exports.assertTSRestType = assertTSRestType;
+exports.assertTSStringKeyword = assertTSStringKeyword;
+exports.assertTSSymbolKeyword = assertTSSymbolKeyword;
+exports.assertTSThisType = assertTSThisType;
+exports.assertTSTupleType = assertTSTupleType;
+exports.assertTSType = assertTSType;
+exports.assertTSTypeAliasDeclaration = assertTSTypeAliasDeclaration;
+exports.assertTSTypeAnnotation = assertTSTypeAnnotation;
+exports.assertTSTypeAssertion = assertTSTypeAssertion;
+exports.assertTSTypeElement = assertTSTypeElement;
+exports.assertTSTypeLiteral = assertTSTypeLiteral;
+exports.assertTSTypeOperator = assertTSTypeOperator;
+exports.assertTSTypeParameter = assertTSTypeParameter;
+exports.assertTSTypeParameterDeclaration = assertTSTypeParameterDeclaration;
+exports.assertTSTypeParameterInstantiation = assertTSTypeParameterInstantiation;
+exports.assertTSTypePredicate = assertTSTypePredicate;
+exports.assertTSTypeQuery = assertTSTypeQuery;
+exports.assertTSTypeReference = assertTSTypeReference;
+exports.assertTSUndefinedKeyword = assertTSUndefinedKeyword;
+exports.assertTSUnionType = assertTSUnionType;
+exports.assertTSUnknownKeyword = assertTSUnknownKeyword;
+exports.assertTSVoidKeyword = assertTSVoidKeyword;
+exports.assertTaggedTemplateExpression = assertTaggedTemplateExpression;
+exports.assertTemplateElement = assertTemplateElement;
+exports.assertTemplateLiteral = assertTemplateLiteral;
+exports.assertTerminatorless = assertTerminatorless;
+exports.assertThisExpression = assertThisExpression;
+exports.assertThisTypeAnnotation = assertThisTypeAnnotation;
+exports.assertThrowStatement = assertThrowStatement;
+exports.assertTopicReference = assertTopicReference;
+exports.assertTryStatement = assertTryStatement;
+exports.assertTupleExpression = assertTupleExpression;
+exports.assertTupleTypeAnnotation = assertTupleTypeAnnotation;
+exports.assertTypeAlias = assertTypeAlias;
+exports.assertTypeAnnotation = assertTypeAnnotation;
+exports.assertTypeCastExpression = assertTypeCastExpression;
+exports.assertTypeParameter = assertTypeParameter;
+exports.assertTypeParameterDeclaration = assertTypeParameterDeclaration;
+exports.assertTypeParameterInstantiation = assertTypeParameterInstantiation;
+exports.assertTypeScript = assertTypeScript;
+exports.assertTypeofTypeAnnotation = assertTypeofTypeAnnotation;
+exports.assertUnaryExpression = assertUnaryExpression;
+exports.assertUnaryLike = assertUnaryLike;
+exports.assertUnionTypeAnnotation = assertUnionTypeAnnotation;
+exports.assertUpdateExpression = assertUpdateExpression;
+exports.assertUserWhitespacable = assertUserWhitespacable;
+exports.assertV8IntrinsicIdentifier = assertV8IntrinsicIdentifier;
+exports.assertVariableDeclaration = assertVariableDeclaration;
+exports.assertVariableDeclarator = assertVariableDeclarator;
+exports.assertVariance = assertVariance;
+exports.assertVoidTypeAnnotation = assertVoidTypeAnnotation;
+exports.assertWhile = assertWhile;
+exports.assertWhileStatement = assertWhileStatement;
+exports.assertWithStatement = assertWithStatement;
+exports.assertYieldExpression = assertYieldExpression;
+
+var _is = require("../../validators/is");
+
+function assert(type, node, opts) {
+ if (!(0, _is.default)(type, node, opts)) {
+ throw new Error(`Expected type "${type}" with option ${JSON.stringify(opts)}, ` + `but instead got "${node.type}".`);
+ }
+}
+
+function assertArrayExpression(node, opts) {
+ assert("ArrayExpression", node, opts);
+}
+
+function assertAssignmentExpression(node, opts) {
+ assert("AssignmentExpression", node, opts);
+}
+
+function assertBinaryExpression(node, opts) {
+ assert("BinaryExpression", node, opts);
+}
+
+function assertInterpreterDirective(node, opts) {
+ assert("InterpreterDirective", node, opts);
+}
+
+function assertDirective(node, opts) {
+ assert("Directive", node, opts);
+}
+
+function assertDirectiveLiteral(node, opts) {
+ assert("DirectiveLiteral", node, opts);
+}
+
+function assertBlockStatement(node, opts) {
+ assert("BlockStatement", node, opts);
+}
+
+function assertBreakStatement(node, opts) {
+ assert("BreakStatement", node, opts);
+}
+
+function assertCallExpression(node, opts) {
+ assert("CallExpression", node, opts);
+}
+
+function assertCatchClause(node, opts) {
+ assert("CatchClause", node, opts);
+}
+
+function assertConditionalExpression(node, opts) {
+ assert("ConditionalExpression", node, opts);
+}
+
+function assertContinueStatement(node, opts) {
+ assert("ContinueStatement", node, opts);
+}
+
+function assertDebuggerStatement(node, opts) {
+ assert("DebuggerStatement", node, opts);
+}
+
+function assertDoWhileStatement(node, opts) {
+ assert("DoWhileStatement", node, opts);
+}
+
+function assertEmptyStatement(node, opts) {
+ assert("EmptyStatement", node, opts);
+}
+
+function assertExpressionStatement(node, opts) {
+ assert("ExpressionStatement", node, opts);
+}
+
+function assertFile(node, opts) {
+ assert("File", node, opts);
+}
+
+function assertForInStatement(node, opts) {
+ assert("ForInStatement", node, opts);
+}
+
+function assertForStatement(node, opts) {
+ assert("ForStatement", node, opts);
+}
+
+function assertFunctionDeclaration(node, opts) {
+ assert("FunctionDeclaration", node, opts);
+}
+
+function assertFunctionExpression(node, opts) {
+ assert("FunctionExpression", node, opts);
+}
+
+function assertIdentifier(node, opts) {
+ assert("Identifier", node, opts);
+}
+
+function assertIfStatement(node, opts) {
+ assert("IfStatement", node, opts);
+}
+
+function assertLabeledStatement(node, opts) {
+ assert("LabeledStatement", node, opts);
+}
+
+function assertStringLiteral(node, opts) {
+ assert("StringLiteral", node, opts);
+}
+
+function assertNumericLiteral(node, opts) {
+ assert("NumericLiteral", node, opts);
+}
+
+function assertNullLiteral(node, opts) {
+ assert("NullLiteral", node, opts);
+}
+
+function assertBooleanLiteral(node, opts) {
+ assert("BooleanLiteral", node, opts);
+}
+
+function assertRegExpLiteral(node, opts) {
+ assert("RegExpLiteral", node, opts);
+}
+
+function assertLogicalExpression(node, opts) {
+ assert("LogicalExpression", node, opts);
+}
+
+function assertMemberExpression(node, opts) {
+ assert("MemberExpression", node, opts);
+}
+
+function assertNewExpression(node, opts) {
+ assert("NewExpression", node, opts);
+}
+
+function assertProgram(node, opts) {
+ assert("Program", node, opts);
+}
+
+function assertObjectExpression(node, opts) {
+ assert("ObjectExpression", node, opts);
+}
+
+function assertObjectMethod(node, opts) {
+ assert("ObjectMethod", node, opts);
+}
+
+function assertObjectProperty(node, opts) {
+ assert("ObjectProperty", node, opts);
+}
+
+function assertRestElement(node, opts) {
+ assert("RestElement", node, opts);
+}
+
+function assertReturnStatement(node, opts) {
+ assert("ReturnStatement", node, opts);
+}
+
+function assertSequenceExpression(node, opts) {
+ assert("SequenceExpression", node, opts);
+}
+
+function assertParenthesizedExpression(node, opts) {
+ assert("ParenthesizedExpression", node, opts);
+}
+
+function assertSwitchCase(node, opts) {
+ assert("SwitchCase", node, opts);
+}
+
+function assertSwitchStatement(node, opts) {
+ assert("SwitchStatement", node, opts);
+}
+
+function assertThisExpression(node, opts) {
+ assert("ThisExpression", node, opts);
+}
+
+function assertThrowStatement(node, opts) {
+ assert("ThrowStatement", node, opts);
+}
+
+function assertTryStatement(node, opts) {
+ assert("TryStatement", node, opts);
+}
+
+function assertUnaryExpression(node, opts) {
+ assert("UnaryExpression", node, opts);
+}
+
+function assertUpdateExpression(node, opts) {
+ assert("UpdateExpression", node, opts);
+}
+
+function assertVariableDeclaration(node, opts) {
+ assert("VariableDeclaration", node, opts);
+}
+
+function assertVariableDeclarator(node, opts) {
+ assert("VariableDeclarator", node, opts);
+}
+
+function assertWhileStatement(node, opts) {
+ assert("WhileStatement", node, opts);
+}
+
+function assertWithStatement(node, opts) {
+ assert("WithStatement", node, opts);
+}
+
+function assertAssignmentPattern(node, opts) {
+ assert("AssignmentPattern", node, opts);
+}
+
+function assertArrayPattern(node, opts) {
+ assert("ArrayPattern", node, opts);
+}
+
+function assertArrowFunctionExpression(node, opts) {
+ assert("ArrowFunctionExpression", node, opts);
+}
+
+function assertClassBody(node, opts) {
+ assert("ClassBody", node, opts);
+}
+
+function assertClassExpression(node, opts) {
+ assert("ClassExpression", node, opts);
+}
+
+function assertClassDeclaration(node, opts) {
+ assert("ClassDeclaration", node, opts);
+}
+
+function assertExportAllDeclaration(node, opts) {
+ assert("ExportAllDeclaration", node, opts);
+}
+
+function assertExportDefaultDeclaration(node, opts) {
+ assert("ExportDefaultDeclaration", node, opts);
+}
+
+function assertExportNamedDeclaration(node, opts) {
+ assert("ExportNamedDeclaration", node, opts);
+}
+
+function assertExportSpecifier(node, opts) {
+ assert("ExportSpecifier", node, opts);
+}
+
+function assertForOfStatement(node, opts) {
+ assert("ForOfStatement", node, opts);
+}
+
+function assertImportDeclaration(node, opts) {
+ assert("ImportDeclaration", node, opts);
+}
+
+function assertImportDefaultSpecifier(node, opts) {
+ assert("ImportDefaultSpecifier", node, opts);
+}
+
+function assertImportNamespaceSpecifier(node, opts) {
+ assert("ImportNamespaceSpecifier", node, opts);
+}
+
+function assertImportSpecifier(node, opts) {
+ assert("ImportSpecifier", node, opts);
+}
+
+function assertMetaProperty(node, opts) {
+ assert("MetaProperty", node, opts);
+}
+
+function assertClassMethod(node, opts) {
+ assert("ClassMethod", node, opts);
+}
+
+function assertObjectPattern(node, opts) {
+ assert("ObjectPattern", node, opts);
+}
+
+function assertSpreadElement(node, opts) {
+ assert("SpreadElement", node, opts);
+}
+
+function assertSuper(node, opts) {
+ assert("Super", node, opts);
+}
+
+function assertTaggedTemplateExpression(node, opts) {
+ assert("TaggedTemplateExpression", node, opts);
+}
+
+function assertTemplateElement(node, opts) {
+ assert("TemplateElement", node, opts);
+}
+
+function assertTemplateLiteral(node, opts) {
+ assert("TemplateLiteral", node, opts);
+}
+
+function assertYieldExpression(node, opts) {
+ assert("YieldExpression", node, opts);
+}
+
+function assertAwaitExpression(node, opts) {
+ assert("AwaitExpression", node, opts);
+}
+
+function assertImport(node, opts) {
+ assert("Import", node, opts);
+}
+
+function assertBigIntLiteral(node, opts) {
+ assert("BigIntLiteral", node, opts);
+}
+
+function assertExportNamespaceSpecifier(node, opts) {
+ assert("ExportNamespaceSpecifier", node, opts);
+}
+
+function assertOptionalMemberExpression(node, opts) {
+ assert("OptionalMemberExpression", node, opts);
+}
+
+function assertOptionalCallExpression(node, opts) {
+ assert("OptionalCallExpression", node, opts);
+}
+
+function assertClassProperty(node, opts) {
+ assert("ClassProperty", node, opts);
+}
+
+function assertClassAccessorProperty(node, opts) {
+ assert("ClassAccessorProperty", node, opts);
+}
+
+function assertClassPrivateProperty(node, opts) {
+ assert("ClassPrivateProperty", node, opts);
+}
+
+function assertClassPrivateMethod(node, opts) {
+ assert("ClassPrivateMethod", node, opts);
+}
+
+function assertPrivateName(node, opts) {
+ assert("PrivateName", node, opts);
+}
+
+function assertStaticBlock(node, opts) {
+ assert("StaticBlock", node, opts);
+}
+
+function assertAnyTypeAnnotation(node, opts) {
+ assert("AnyTypeAnnotation", node, opts);
+}
+
+function assertArrayTypeAnnotation(node, opts) {
+ assert("ArrayTypeAnnotation", node, opts);
+}
+
+function assertBooleanTypeAnnotation(node, opts) {
+ assert("BooleanTypeAnnotation", node, opts);
+}
+
+function assertBooleanLiteralTypeAnnotation(node, opts) {
+ assert("BooleanLiteralTypeAnnotation", node, opts);
+}
+
+function assertNullLiteralTypeAnnotation(node, opts) {
+ assert("NullLiteralTypeAnnotation", node, opts);
+}
+
+function assertClassImplements(node, opts) {
+ assert("ClassImplements", node, opts);
+}
+
+function assertDeclareClass(node, opts) {
+ assert("DeclareClass", node, opts);
+}
+
+function assertDeclareFunction(node, opts) {
+ assert("DeclareFunction", node, opts);
+}
+
+function assertDeclareInterface(node, opts) {
+ assert("DeclareInterface", node, opts);
+}
+
+function assertDeclareModule(node, opts) {
+ assert("DeclareModule", node, opts);
+}
+
+function assertDeclareModuleExports(node, opts) {
+ assert("DeclareModuleExports", node, opts);
+}
+
+function assertDeclareTypeAlias(node, opts) {
+ assert("DeclareTypeAlias", node, opts);
+}
+
+function assertDeclareOpaqueType(node, opts) {
+ assert("DeclareOpaqueType", node, opts);
+}
+
+function assertDeclareVariable(node, opts) {
+ assert("DeclareVariable", node, opts);
+}
+
+function assertDeclareExportDeclaration(node, opts) {
+ assert("DeclareExportDeclaration", node, opts);
+}
+
+function assertDeclareExportAllDeclaration(node, opts) {
+ assert("DeclareExportAllDeclaration", node, opts);
+}
+
+function assertDeclaredPredicate(node, opts) {
+ assert("DeclaredPredicate", node, opts);
+}
+
+function assertExistsTypeAnnotation(node, opts) {
+ assert("ExistsTypeAnnotation", node, opts);
+}
+
+function assertFunctionTypeAnnotation(node, opts) {
+ assert("FunctionTypeAnnotation", node, opts);
+}
+
+function assertFunctionTypeParam(node, opts) {
+ assert("FunctionTypeParam", node, opts);
+}
+
+function assertGenericTypeAnnotation(node, opts) {
+ assert("GenericTypeAnnotation", node, opts);
+}
+
+function assertInferredPredicate(node, opts) {
+ assert("InferredPredicate", node, opts);
+}
+
+function assertInterfaceExtends(node, opts) {
+ assert("InterfaceExtends", node, opts);
+}
+
+function assertInterfaceDeclaration(node, opts) {
+ assert("InterfaceDeclaration", node, opts);
+}
+
+function assertInterfaceTypeAnnotation(node, opts) {
+ assert("InterfaceTypeAnnotation", node, opts);
+}
+
+function assertIntersectionTypeAnnotation(node, opts) {
+ assert("IntersectionTypeAnnotation", node, opts);
+}
+
+function assertMixedTypeAnnotation(node, opts) {
+ assert("MixedTypeAnnotation", node, opts);
+}
+
+function assertEmptyTypeAnnotation(node, opts) {
+ assert("EmptyTypeAnnotation", node, opts);
+}
+
+function assertNullableTypeAnnotation(node, opts) {
+ assert("NullableTypeAnnotation", node, opts);
+}
+
+function assertNumberLiteralTypeAnnotation(node, opts) {
+ assert("NumberLiteralTypeAnnotation", node, opts);
+}
+
+function assertNumberTypeAnnotation(node, opts) {
+ assert("NumberTypeAnnotation", node, opts);
+}
+
+function assertObjectTypeAnnotation(node, opts) {
+ assert("ObjectTypeAnnotation", node, opts);
+}
+
+function assertObjectTypeInternalSlot(node, opts) {
+ assert("ObjectTypeInternalSlot", node, opts);
+}
+
+function assertObjectTypeCallProperty(node, opts) {
+ assert("ObjectTypeCallProperty", node, opts);
+}
+
+function assertObjectTypeIndexer(node, opts) {
+ assert("ObjectTypeIndexer", node, opts);
+}
+
+function assertObjectTypeProperty(node, opts) {
+ assert("ObjectTypeProperty", node, opts);
+}
+
+function assertObjectTypeSpreadProperty(node, opts) {
+ assert("ObjectTypeSpreadProperty", node, opts);
+}
+
+function assertOpaqueType(node, opts) {
+ assert("OpaqueType", node, opts);
+}
+
+function assertQualifiedTypeIdentifier(node, opts) {
+ assert("QualifiedTypeIdentifier", node, opts);
+}
+
+function assertStringLiteralTypeAnnotation(node, opts) {
+ assert("StringLiteralTypeAnnotation", node, opts);
+}
+
+function assertStringTypeAnnotation(node, opts) {
+ assert("StringTypeAnnotation", node, opts);
+}
+
+function assertSymbolTypeAnnotation(node, opts) {
+ assert("SymbolTypeAnnotation", node, opts);
+}
+
+function assertThisTypeAnnotation(node, opts) {
+ assert("ThisTypeAnnotation", node, opts);
+}
+
+function assertTupleTypeAnnotation(node, opts) {
+ assert("TupleTypeAnnotation", node, opts);
+}
+
+function assertTypeofTypeAnnotation(node, opts) {
+ assert("TypeofTypeAnnotation", node, opts);
+}
+
+function assertTypeAlias(node, opts) {
+ assert("TypeAlias", node, opts);
+}
+
+function assertTypeAnnotation(node, opts) {
+ assert("TypeAnnotation", node, opts);
+}
+
+function assertTypeCastExpression(node, opts) {
+ assert("TypeCastExpression", node, opts);
+}
+
+function assertTypeParameter(node, opts) {
+ assert("TypeParameter", node, opts);
+}
+
+function assertTypeParameterDeclaration(node, opts) {
+ assert("TypeParameterDeclaration", node, opts);
+}
+
+function assertTypeParameterInstantiation(node, opts) {
+ assert("TypeParameterInstantiation", node, opts);
+}
+
+function assertUnionTypeAnnotation(node, opts) {
+ assert("UnionTypeAnnotation", node, opts);
+}
+
+function assertVariance(node, opts) {
+ assert("Variance", node, opts);
+}
+
+function assertVoidTypeAnnotation(node, opts) {
+ assert("VoidTypeAnnotation", node, opts);
+}
+
+function assertEnumDeclaration(node, opts) {
+ assert("EnumDeclaration", node, opts);
+}
+
+function assertEnumBooleanBody(node, opts) {
+ assert("EnumBooleanBody", node, opts);
+}
+
+function assertEnumNumberBody(node, opts) {
+ assert("EnumNumberBody", node, opts);
+}
+
+function assertEnumStringBody(node, opts) {
+ assert("EnumStringBody", node, opts);
+}
+
+function assertEnumSymbolBody(node, opts) {
+ assert("EnumSymbolBody", node, opts);
+}
+
+function assertEnumBooleanMember(node, opts) {
+ assert("EnumBooleanMember", node, opts);
+}
+
+function assertEnumNumberMember(node, opts) {
+ assert("EnumNumberMember", node, opts);
+}
+
+function assertEnumStringMember(node, opts) {
+ assert("EnumStringMember", node, opts);
+}
+
+function assertEnumDefaultedMember(node, opts) {
+ assert("EnumDefaultedMember", node, opts);
+}
+
+function assertIndexedAccessType(node, opts) {
+ assert("IndexedAccessType", node, opts);
+}
+
+function assertOptionalIndexedAccessType(node, opts) {
+ assert("OptionalIndexedAccessType", node, opts);
+}
+
+function assertJSXAttribute(node, opts) {
+ assert("JSXAttribute", node, opts);
+}
+
+function assertJSXClosingElement(node, opts) {
+ assert("JSXClosingElement", node, opts);
+}
+
+function assertJSXElement(node, opts) {
+ assert("JSXElement", node, opts);
+}
+
+function assertJSXEmptyExpression(node, opts) {
+ assert("JSXEmptyExpression", node, opts);
+}
+
+function assertJSXExpressionContainer(node, opts) {
+ assert("JSXExpressionContainer", node, opts);
+}
+
+function assertJSXSpreadChild(node, opts) {
+ assert("JSXSpreadChild", node, opts);
+}
+
+function assertJSXIdentifier(node, opts) {
+ assert("JSXIdentifier", node, opts);
+}
+
+function assertJSXMemberExpression(node, opts) {
+ assert("JSXMemberExpression", node, opts);
+}
+
+function assertJSXNamespacedName(node, opts) {
+ assert("JSXNamespacedName", node, opts);
+}
+
+function assertJSXOpeningElement(node, opts) {
+ assert("JSXOpeningElement", node, opts);
+}
+
+function assertJSXSpreadAttribute(node, opts) {
+ assert("JSXSpreadAttribute", node, opts);
+}
+
+function assertJSXText(node, opts) {
+ assert("JSXText", node, opts);
+}
+
+function assertJSXFragment(node, opts) {
+ assert("JSXFragment", node, opts);
+}
+
+function assertJSXOpeningFragment(node, opts) {
+ assert("JSXOpeningFragment", node, opts);
+}
+
+function assertJSXClosingFragment(node, opts) {
+ assert("JSXClosingFragment", node, opts);
+}
+
+function assertNoop(node, opts) {
+ assert("Noop", node, opts);
+}
+
+function assertPlaceholder(node, opts) {
+ assert("Placeholder", node, opts);
+}
+
+function assertV8IntrinsicIdentifier(node, opts) {
+ assert("V8IntrinsicIdentifier", node, opts);
+}
+
+function assertArgumentPlaceholder(node, opts) {
+ assert("ArgumentPlaceholder", node, opts);
+}
+
+function assertBindExpression(node, opts) {
+ assert("BindExpression", node, opts);
+}
+
+function assertImportAttribute(node, opts) {
+ assert("ImportAttribute", node, opts);
+}
+
+function assertDecorator(node, opts) {
+ assert("Decorator", node, opts);
+}
+
+function assertDoExpression(node, opts) {
+ assert("DoExpression", node, opts);
+}
+
+function assertExportDefaultSpecifier(node, opts) {
+ assert("ExportDefaultSpecifier", node, opts);
+}
+
+function assertRecordExpression(node, opts) {
+ assert("RecordExpression", node, opts);
+}
+
+function assertTupleExpression(node, opts) {
+ assert("TupleExpression", node, opts);
+}
+
+function assertDecimalLiteral(node, opts) {
+ assert("DecimalLiteral", node, opts);
+}
+
+function assertModuleExpression(node, opts) {
+ assert("ModuleExpression", node, opts);
+}
+
+function assertTopicReference(node, opts) {
+ assert("TopicReference", node, opts);
+}
+
+function assertPipelineTopicExpression(node, opts) {
+ assert("PipelineTopicExpression", node, opts);
+}
+
+function assertPipelineBareFunction(node, opts) {
+ assert("PipelineBareFunction", node, opts);
+}
+
+function assertPipelinePrimaryTopicReference(node, opts) {
+ assert("PipelinePrimaryTopicReference", node, opts);
+}
+
+function assertTSParameterProperty(node, opts) {
+ assert("TSParameterProperty", node, opts);
+}
+
+function assertTSDeclareFunction(node, opts) {
+ assert("TSDeclareFunction", node, opts);
+}
+
+function assertTSDeclareMethod(node, opts) {
+ assert("TSDeclareMethod", node, opts);
+}
+
+function assertTSQualifiedName(node, opts) {
+ assert("TSQualifiedName", node, opts);
+}
+
+function assertTSCallSignatureDeclaration(node, opts) {
+ assert("TSCallSignatureDeclaration", node, opts);
+}
+
+function assertTSConstructSignatureDeclaration(node, opts) {
+ assert("TSConstructSignatureDeclaration", node, opts);
+}
+
+function assertTSPropertySignature(node, opts) {
+ assert("TSPropertySignature", node, opts);
+}
+
+function assertTSMethodSignature(node, opts) {
+ assert("TSMethodSignature", node, opts);
+}
+
+function assertTSIndexSignature(node, opts) {
+ assert("TSIndexSignature", node, opts);
+}
+
+function assertTSAnyKeyword(node, opts) {
+ assert("TSAnyKeyword", node, opts);
+}
+
+function assertTSBooleanKeyword(node, opts) {
+ assert("TSBooleanKeyword", node, opts);
+}
+
+function assertTSBigIntKeyword(node, opts) {
+ assert("TSBigIntKeyword", node, opts);
+}
+
+function assertTSIntrinsicKeyword(node, opts) {
+ assert("TSIntrinsicKeyword", node, opts);
+}
+
+function assertTSNeverKeyword(node, opts) {
+ assert("TSNeverKeyword", node, opts);
+}
+
+function assertTSNullKeyword(node, opts) {
+ assert("TSNullKeyword", node, opts);
+}
+
+function assertTSNumberKeyword(node, opts) {
+ assert("TSNumberKeyword", node, opts);
+}
+
+function assertTSObjectKeyword(node, opts) {
+ assert("TSObjectKeyword", node, opts);
+}
+
+function assertTSStringKeyword(node, opts) {
+ assert("TSStringKeyword", node, opts);
+}
+
+function assertTSSymbolKeyword(node, opts) {
+ assert("TSSymbolKeyword", node, opts);
+}
+
+function assertTSUndefinedKeyword(node, opts) {
+ assert("TSUndefinedKeyword", node, opts);
+}
+
+function assertTSUnknownKeyword(node, opts) {
+ assert("TSUnknownKeyword", node, opts);
+}
+
+function assertTSVoidKeyword(node, opts) {
+ assert("TSVoidKeyword", node, opts);
+}
+
+function assertTSThisType(node, opts) {
+ assert("TSThisType", node, opts);
+}
+
+function assertTSFunctionType(node, opts) {
+ assert("TSFunctionType", node, opts);
+}
+
+function assertTSConstructorType(node, opts) {
+ assert("TSConstructorType", node, opts);
+}
+
+function assertTSTypeReference(node, opts) {
+ assert("TSTypeReference", node, opts);
+}
+
+function assertTSTypePredicate(node, opts) {
+ assert("TSTypePredicate", node, opts);
+}
+
+function assertTSTypeQuery(node, opts) {
+ assert("TSTypeQuery", node, opts);
+}
+
+function assertTSTypeLiteral(node, opts) {
+ assert("TSTypeLiteral", node, opts);
+}
+
+function assertTSArrayType(node, opts) {
+ assert("TSArrayType", node, opts);
+}
+
+function assertTSTupleType(node, opts) {
+ assert("TSTupleType", node, opts);
+}
+
+function assertTSOptionalType(node, opts) {
+ assert("TSOptionalType", node, opts);
+}
+
+function assertTSRestType(node, opts) {
+ assert("TSRestType", node, opts);
+}
+
+function assertTSNamedTupleMember(node, opts) {
+ assert("TSNamedTupleMember", node, opts);
+}
+
+function assertTSUnionType(node, opts) {
+ assert("TSUnionType", node, opts);
+}
+
+function assertTSIntersectionType(node, opts) {
+ assert("TSIntersectionType", node, opts);
+}
+
+function assertTSConditionalType(node, opts) {
+ assert("TSConditionalType", node, opts);
+}
+
+function assertTSInferType(node, opts) {
+ assert("TSInferType", node, opts);
+}
+
+function assertTSParenthesizedType(node, opts) {
+ assert("TSParenthesizedType", node, opts);
+}
+
+function assertTSTypeOperator(node, opts) {
+ assert("TSTypeOperator", node, opts);
+}
+
+function assertTSIndexedAccessType(node, opts) {
+ assert("TSIndexedAccessType", node, opts);
+}
+
+function assertTSMappedType(node, opts) {
+ assert("TSMappedType", node, opts);
+}
+
+function assertTSLiteralType(node, opts) {
+ assert("TSLiteralType", node, opts);
+}
+
+function assertTSExpressionWithTypeArguments(node, opts) {
+ assert("TSExpressionWithTypeArguments", node, opts);
+}
+
+function assertTSInterfaceDeclaration(node, opts) {
+ assert("TSInterfaceDeclaration", node, opts);
+}
+
+function assertTSInterfaceBody(node, opts) {
+ assert("TSInterfaceBody", node, opts);
+}
+
+function assertTSTypeAliasDeclaration(node, opts) {
+ assert("TSTypeAliasDeclaration", node, opts);
+}
+
+function assertTSAsExpression(node, opts) {
+ assert("TSAsExpression", node, opts);
+}
+
+function assertTSTypeAssertion(node, opts) {
+ assert("TSTypeAssertion", node, opts);
+}
+
+function assertTSEnumDeclaration(node, opts) {
+ assert("TSEnumDeclaration", node, opts);
+}
+
+function assertTSEnumMember(node, opts) {
+ assert("TSEnumMember", node, opts);
+}
+
+function assertTSModuleDeclaration(node, opts) {
+ assert("TSModuleDeclaration", node, opts);
+}
+
+function assertTSModuleBlock(node, opts) {
+ assert("TSModuleBlock", node, opts);
+}
+
+function assertTSImportType(node, opts) {
+ assert("TSImportType", node, opts);
+}
+
+function assertTSImportEqualsDeclaration(node, opts) {
+ assert("TSImportEqualsDeclaration", node, opts);
+}
+
+function assertTSExternalModuleReference(node, opts) {
+ assert("TSExternalModuleReference", node, opts);
+}
+
+function assertTSNonNullExpression(node, opts) {
+ assert("TSNonNullExpression", node, opts);
+}
+
+function assertTSExportAssignment(node, opts) {
+ assert("TSExportAssignment", node, opts);
+}
+
+function assertTSNamespaceExportDeclaration(node, opts) {
+ assert("TSNamespaceExportDeclaration", node, opts);
+}
+
+function assertTSTypeAnnotation(node, opts) {
+ assert("TSTypeAnnotation", node, opts);
+}
+
+function assertTSTypeParameterInstantiation(node, opts) {
+ assert("TSTypeParameterInstantiation", node, opts);
+}
+
+function assertTSTypeParameterDeclaration(node, opts) {
+ assert("TSTypeParameterDeclaration", node, opts);
+}
+
+function assertTSTypeParameter(node, opts) {
+ assert("TSTypeParameter", node, opts);
+}
+
+function assertStandardized(node, opts) {
+ assert("Standardized", node, opts);
+}
+
+function assertExpression(node, opts) {
+ assert("Expression", node, opts);
+}
+
+function assertBinary(node, opts) {
+ assert("Binary", node, opts);
+}
+
+function assertScopable(node, opts) {
+ assert("Scopable", node, opts);
+}
+
+function assertBlockParent(node, opts) {
+ assert("BlockParent", node, opts);
+}
+
+function assertBlock(node, opts) {
+ assert("Block", node, opts);
+}
+
+function assertStatement(node, opts) {
+ assert("Statement", node, opts);
+}
+
+function assertTerminatorless(node, opts) {
+ assert("Terminatorless", node, opts);
+}
+
+function assertCompletionStatement(node, opts) {
+ assert("CompletionStatement", node, opts);
+}
+
+function assertConditional(node, opts) {
+ assert("Conditional", node, opts);
+}
+
+function assertLoop(node, opts) {
+ assert("Loop", node, opts);
+}
+
+function assertWhile(node, opts) {
+ assert("While", node, opts);
+}
+
+function assertExpressionWrapper(node, opts) {
+ assert("ExpressionWrapper", node, opts);
+}
+
+function assertFor(node, opts) {
+ assert("For", node, opts);
+}
+
+function assertForXStatement(node, opts) {
+ assert("ForXStatement", node, opts);
+}
+
+function assertFunction(node, opts) {
+ assert("Function", node, opts);
+}
+
+function assertFunctionParent(node, opts) {
+ assert("FunctionParent", node, opts);
+}
+
+function assertPureish(node, opts) {
+ assert("Pureish", node, opts);
+}
+
+function assertDeclaration(node, opts) {
+ assert("Declaration", node, opts);
+}
+
+function assertPatternLike(node, opts) {
+ assert("PatternLike", node, opts);
+}
+
+function assertLVal(node, opts) {
+ assert("LVal", node, opts);
+}
+
+function assertTSEntityName(node, opts) {
+ assert("TSEntityName", node, opts);
+}
+
+function assertLiteral(node, opts) {
+ assert("Literal", node, opts);
+}
+
+function assertImmutable(node, opts) {
+ assert("Immutable", node, opts);
+}
+
+function assertUserWhitespacable(node, opts) {
+ assert("UserWhitespacable", node, opts);
+}
+
+function assertMethod(node, opts) {
+ assert("Method", node, opts);
+}
+
+function assertObjectMember(node, opts) {
+ assert("ObjectMember", node, opts);
+}
+
+function assertProperty(node, opts) {
+ assert("Property", node, opts);
+}
+
+function assertUnaryLike(node, opts) {
+ assert("UnaryLike", node, opts);
+}
+
+function assertPattern(node, opts) {
+ assert("Pattern", node, opts);
+}
+
+function assertClass(node, opts) {
+ assert("Class", node, opts);
+}
+
+function assertModuleDeclaration(node, opts) {
+ assert("ModuleDeclaration", node, opts);
+}
+
+function assertExportDeclaration(node, opts) {
+ assert("ExportDeclaration", node, opts);
+}
+
+function assertModuleSpecifier(node, opts) {
+ assert("ModuleSpecifier", node, opts);
+}
+
+function assertAccessor(node, opts) {
+ assert("Accessor", node, opts);
+}
+
+function assertPrivate(node, opts) {
+ assert("Private", node, opts);
+}
+
+function assertFlow(node, opts) {
+ assert("Flow", node, opts);
+}
+
+function assertFlowType(node, opts) {
+ assert("FlowType", node, opts);
+}
+
+function assertFlowBaseAnnotation(node, opts) {
+ assert("FlowBaseAnnotation", node, opts);
+}
+
+function assertFlowDeclaration(node, opts) {
+ assert("FlowDeclaration", node, opts);
+}
+
+function assertFlowPredicate(node, opts) {
+ assert("FlowPredicate", node, opts);
+}
+
+function assertEnumBody(node, opts) {
+ assert("EnumBody", node, opts);
+}
+
+function assertEnumMember(node, opts) {
+ assert("EnumMember", node, opts);
+}
+
+function assertJSX(node, opts) {
+ assert("JSX", node, opts);
+}
+
+function assertMiscellaneous(node, opts) {
+ assert("Miscellaneous", node, opts);
+}
+
+function assertTypeScript(node, opts) {
+ assert("TypeScript", node, opts);
+}
+
+function assertTSTypeElement(node, opts) {
+ assert("TSTypeElement", node, opts);
+}
+
+function assertTSType(node, opts) {
+ assert("TSType", node, opts);
+}
+
+function assertTSBaseType(node, opts) {
+ assert("TSBaseType", node, opts);
+}
+
+function assertNumberLiteral(node, opts) {
+ console.trace("The node type NumberLiteral has been renamed to NumericLiteral");
+ assert("NumberLiteral", node, opts);
+}
+
+function assertRegexLiteral(node, opts) {
+ console.trace("The node type RegexLiteral has been renamed to RegExpLiteral");
+ assert("RegexLiteral", node, opts);
+}
+
+function assertRestProperty(node, opts) {
+ console.trace("The node type RestProperty has been renamed to RestElement");
+ assert("RestProperty", node, opts);
+}
+
+function assertSpreadProperty(node, opts) {
+ console.trace("The node type SpreadProperty has been renamed to SpreadElement");
+ assert("SpreadProperty", node, opts);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/ast-types/generated/index.js b/node_modules/@babel/types/lib/ast-types/generated/index.js
new file mode 100644
index 000000000..e69de29bb
diff --git a/node_modules/@babel/types/lib/builders/builder.js b/node_modules/@babel/types/lib/builders/builder.js
new file mode 100644
index 000000000..c28edb625
--- /dev/null
+++ b/node_modules/@babel/types/lib/builders/builder.js
@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = builder;
+
+var _definitions = require("../definitions");
+
+var _validate = require("../validators/validate");
+
+function builder() {
+ const type = this;
+ const keys = _definitions.BUILDER_KEYS[type];
+ const countArgs = arguments.length;
+
+ if (countArgs > keys.length) {
+ throw new Error(`${type}: Too many arguments passed. Received ${countArgs} but can receive no more than ${keys.length}`);
+ }
+
+ const node = {
+ type
+ };
+
+ for (let i = 0; i < keys.length; ++i) {
+ const key = keys[i];
+ const field = _definitions.NODE_FIELDS[type][key];
+ let arg;
+ if (i < countArgs) arg = arguments[i];
+
+ if (arg === undefined) {
+ arg = Array.isArray(field.default) ? [] : field.default;
+ }
+
+ node[key] = arg;
+ }
+
+ for (const key in node) {
+ (0, _validate.default)(node, key, node[key]);
+ }
+
+ return node;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/builders/flow/createFlowUnionType.js b/node_modules/@babel/types/lib/builders/flow/createFlowUnionType.js
new file mode 100644
index 000000000..ddf20fdd3
--- /dev/null
+++ b/node_modules/@babel/types/lib/builders/flow/createFlowUnionType.js
@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = createFlowUnionType;
+
+var _generated = require("../generated");
+
+var _removeTypeDuplicates = require("../../modifications/flow/removeTypeDuplicates");
+
+function createFlowUnionType(types) {
+ const flattened = (0, _removeTypeDuplicates.default)(types);
+
+ if (flattened.length === 1) {
+ return flattened[0];
+ } else {
+ return (0, _generated.unionTypeAnnotation)(flattened);
+ }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/builders/flow/createTypeAnnotationBasedOnTypeof.js b/node_modules/@babel/types/lib/builders/flow/createTypeAnnotationBasedOnTypeof.js
new file mode 100644
index 000000000..11dca0559
--- /dev/null
+++ b/node_modules/@babel/types/lib/builders/flow/createTypeAnnotationBasedOnTypeof.js
@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = void 0;
+
+var _generated = require("../generated");
+
+var _default = createTypeAnnotationBasedOnTypeof;
+exports.default = _default;
+
+function createTypeAnnotationBasedOnTypeof(type) {
+ switch (type) {
+ case "string":
+ return (0, _generated.stringTypeAnnotation)();
+
+ case "number":
+ return (0, _generated.numberTypeAnnotation)();
+
+ case "undefined":
+ return (0, _generated.voidTypeAnnotation)();
+
+ case "boolean":
+ return (0, _generated.booleanTypeAnnotation)();
+
+ case "function":
+ return (0, _generated.genericTypeAnnotation)((0, _generated.identifier)("Function"));
+
+ case "object":
+ return (0, _generated.genericTypeAnnotation)((0, _generated.identifier)("Object"));
+
+ case "symbol":
+ return (0, _generated.genericTypeAnnotation)((0, _generated.identifier)("Symbol"));
+
+ case "bigint":
+ return (0, _generated.anyTypeAnnotation)();
+ }
+
+ throw new Error("Invalid typeof value: " + type);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/builders/generated/index.js b/node_modules/@babel/types/lib/builders/generated/index.js
new file mode 100644
index 000000000..99851ee0b
--- /dev/null
+++ b/node_modules/@babel/types/lib/builders/generated/index.js
@@ -0,0 +1,1266 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.anyTypeAnnotation = anyTypeAnnotation;
+exports.argumentPlaceholder = argumentPlaceholder;
+exports.arrayExpression = arrayExpression;
+exports.arrayPattern = arrayPattern;
+exports.arrayTypeAnnotation = arrayTypeAnnotation;
+exports.arrowFunctionExpression = arrowFunctionExpression;
+exports.assignmentExpression = assignmentExpression;
+exports.assignmentPattern = assignmentPattern;
+exports.awaitExpression = awaitExpression;
+exports.bigIntLiteral = bigIntLiteral;
+exports.binaryExpression = binaryExpression;
+exports.bindExpression = bindExpression;
+exports.blockStatement = blockStatement;
+exports.booleanLiteral = booleanLiteral;
+exports.booleanLiteralTypeAnnotation = booleanLiteralTypeAnnotation;
+exports.booleanTypeAnnotation = booleanTypeAnnotation;
+exports.breakStatement = breakStatement;
+exports.callExpression = callExpression;
+exports.catchClause = catchClause;
+exports.classAccessorProperty = classAccessorProperty;
+exports.classBody = classBody;
+exports.classDeclaration = classDeclaration;
+exports.classExpression = classExpression;
+exports.classImplements = classImplements;
+exports.classMethod = classMethod;
+exports.classPrivateMethod = classPrivateMethod;
+exports.classPrivateProperty = classPrivateProperty;
+exports.classProperty = classProperty;
+exports.conditionalExpression = conditionalExpression;
+exports.continueStatement = continueStatement;
+exports.debuggerStatement = debuggerStatement;
+exports.decimalLiteral = decimalLiteral;
+exports.declareClass = declareClass;
+exports.declareExportAllDeclaration = declareExportAllDeclaration;
+exports.declareExportDeclaration = declareExportDeclaration;
+exports.declareFunction = declareFunction;
+exports.declareInterface = declareInterface;
+exports.declareModule = declareModule;
+exports.declareModuleExports = declareModuleExports;
+exports.declareOpaqueType = declareOpaqueType;
+exports.declareTypeAlias = declareTypeAlias;
+exports.declareVariable = declareVariable;
+exports.declaredPredicate = declaredPredicate;
+exports.decorator = decorator;
+exports.directive = directive;
+exports.directiveLiteral = directiveLiteral;
+exports.doExpression = doExpression;
+exports.doWhileStatement = doWhileStatement;
+exports.emptyStatement = emptyStatement;
+exports.emptyTypeAnnotation = emptyTypeAnnotation;
+exports.enumBooleanBody = enumBooleanBody;
+exports.enumBooleanMember = enumBooleanMember;
+exports.enumDeclaration = enumDeclaration;
+exports.enumDefaultedMember = enumDefaultedMember;
+exports.enumNumberBody = enumNumberBody;
+exports.enumNumberMember = enumNumberMember;
+exports.enumStringBody = enumStringBody;
+exports.enumStringMember = enumStringMember;
+exports.enumSymbolBody = enumSymbolBody;
+exports.existsTypeAnnotation = existsTypeAnnotation;
+exports.exportAllDeclaration = exportAllDeclaration;
+exports.exportDefaultDeclaration = exportDefaultDeclaration;
+exports.exportDefaultSpecifier = exportDefaultSpecifier;
+exports.exportNamedDeclaration = exportNamedDeclaration;
+exports.exportNamespaceSpecifier = exportNamespaceSpecifier;
+exports.exportSpecifier = exportSpecifier;
+exports.expressionStatement = expressionStatement;
+exports.file = file;
+exports.forInStatement = forInStatement;
+exports.forOfStatement = forOfStatement;
+exports.forStatement = forStatement;
+exports.functionDeclaration = functionDeclaration;
+exports.functionExpression = functionExpression;
+exports.functionTypeAnnotation = functionTypeAnnotation;
+exports.functionTypeParam = functionTypeParam;
+exports.genericTypeAnnotation = genericTypeAnnotation;
+exports.identifier = identifier;
+exports.ifStatement = ifStatement;
+exports.import = _import;
+exports.importAttribute = importAttribute;
+exports.importDeclaration = importDeclaration;
+exports.importDefaultSpecifier = importDefaultSpecifier;
+exports.importNamespaceSpecifier = importNamespaceSpecifier;
+exports.importSpecifier = importSpecifier;
+exports.indexedAccessType = indexedAccessType;
+exports.inferredPredicate = inferredPredicate;
+exports.interfaceDeclaration = interfaceDeclaration;
+exports.interfaceExtends = interfaceExtends;
+exports.interfaceTypeAnnotation = interfaceTypeAnnotation;
+exports.interpreterDirective = interpreterDirective;
+exports.intersectionTypeAnnotation = intersectionTypeAnnotation;
+exports.jSXAttribute = exports.jsxAttribute = jsxAttribute;
+exports.jSXClosingElement = exports.jsxClosingElement = jsxClosingElement;
+exports.jSXClosingFragment = exports.jsxClosingFragment = jsxClosingFragment;
+exports.jSXElement = exports.jsxElement = jsxElement;
+exports.jSXEmptyExpression = exports.jsxEmptyExpression = jsxEmptyExpression;
+exports.jSXExpressionContainer = exports.jsxExpressionContainer = jsxExpressionContainer;
+exports.jSXFragment = exports.jsxFragment = jsxFragment;
+exports.jSXIdentifier = exports.jsxIdentifier = jsxIdentifier;
+exports.jSXMemberExpression = exports.jsxMemberExpression = jsxMemberExpression;
+exports.jSXNamespacedName = exports.jsxNamespacedName = jsxNamespacedName;
+exports.jSXOpeningElement = exports.jsxOpeningElement = jsxOpeningElement;
+exports.jSXOpeningFragment = exports.jsxOpeningFragment = jsxOpeningFragment;
+exports.jSXSpreadAttribute = exports.jsxSpreadAttribute = jsxSpreadAttribute;
+exports.jSXSpreadChild = exports.jsxSpreadChild = jsxSpreadChild;
+exports.jSXText = exports.jsxText = jsxText;
+exports.labeledStatement = labeledStatement;
+exports.logicalExpression = logicalExpression;
+exports.memberExpression = memberExpression;
+exports.metaProperty = metaProperty;
+exports.mixedTypeAnnotation = mixedTypeAnnotation;
+exports.moduleExpression = moduleExpression;
+exports.newExpression = newExpression;
+exports.noop = noop;
+exports.nullLiteral = nullLiteral;
+exports.nullLiteralTypeAnnotation = nullLiteralTypeAnnotation;
+exports.nullableTypeAnnotation = nullableTypeAnnotation;
+exports.numberLiteral = NumberLiteral;
+exports.numberLiteralTypeAnnotation = numberLiteralTypeAnnotation;
+exports.numberTypeAnnotation = numberTypeAnnotation;
+exports.numericLiteral = numericLiteral;
+exports.objectExpression = objectExpression;
+exports.objectMethod = objectMethod;
+exports.objectPattern = objectPattern;
+exports.objectProperty = objectProperty;
+exports.objectTypeAnnotation = objectTypeAnnotation;
+exports.objectTypeCallProperty = objectTypeCallProperty;
+exports.objectTypeIndexer = objectTypeIndexer;
+exports.objectTypeInternalSlot = objectTypeInternalSlot;
+exports.objectTypeProperty = objectTypeProperty;
+exports.objectTypeSpreadProperty = objectTypeSpreadProperty;
+exports.opaqueType = opaqueType;
+exports.optionalCallExpression = optionalCallExpression;
+exports.optionalIndexedAccessType = optionalIndexedAccessType;
+exports.optionalMemberExpression = optionalMemberExpression;
+exports.parenthesizedExpression = parenthesizedExpression;
+exports.pipelineBareFunction = pipelineBareFunction;
+exports.pipelinePrimaryTopicReference = pipelinePrimaryTopicReference;
+exports.pipelineTopicExpression = pipelineTopicExpression;
+exports.placeholder = placeholder;
+exports.privateName = privateName;
+exports.program = program;
+exports.qualifiedTypeIdentifier = qualifiedTypeIdentifier;
+exports.recordExpression = recordExpression;
+exports.regExpLiteral = regExpLiteral;
+exports.regexLiteral = RegexLiteral;
+exports.restElement = restElement;
+exports.restProperty = RestProperty;
+exports.returnStatement = returnStatement;
+exports.sequenceExpression = sequenceExpression;
+exports.spreadElement = spreadElement;
+exports.spreadProperty = SpreadProperty;
+exports.staticBlock = staticBlock;
+exports.stringLiteral = stringLiteral;
+exports.stringLiteralTypeAnnotation = stringLiteralTypeAnnotation;
+exports.stringTypeAnnotation = stringTypeAnnotation;
+exports.super = _super;
+exports.switchCase = switchCase;
+exports.switchStatement = switchStatement;
+exports.symbolTypeAnnotation = symbolTypeAnnotation;
+exports.taggedTemplateExpression = taggedTemplateExpression;
+exports.templateElement = templateElement;
+exports.templateLiteral = templateLiteral;
+exports.thisExpression = thisExpression;
+exports.thisTypeAnnotation = thisTypeAnnotation;
+exports.throwStatement = throwStatement;
+exports.topicReference = topicReference;
+exports.tryStatement = tryStatement;
+exports.tSAnyKeyword = exports.tsAnyKeyword = tsAnyKeyword;
+exports.tSArrayType = exports.tsArrayType = tsArrayType;
+exports.tSAsExpression = exports.tsAsExpression = tsAsExpression;
+exports.tSBigIntKeyword = exports.tsBigIntKeyword = tsBigIntKeyword;
+exports.tSBooleanKeyword = exports.tsBooleanKeyword = tsBooleanKeyword;
+exports.tSCallSignatureDeclaration = exports.tsCallSignatureDeclaration = tsCallSignatureDeclaration;
+exports.tSConditionalType = exports.tsConditionalType = tsConditionalType;
+exports.tSConstructSignatureDeclaration = exports.tsConstructSignatureDeclaration = tsConstructSignatureDeclaration;
+exports.tSConstructorType = exports.tsConstructorType = tsConstructorType;
+exports.tSDeclareFunction = exports.tsDeclareFunction = tsDeclareFunction;
+exports.tSDeclareMethod = exports.tsDeclareMethod = tsDeclareMethod;
+exports.tSEnumDeclaration = exports.tsEnumDeclaration = tsEnumDeclaration;
+exports.tSEnumMember = exports.tsEnumMember = tsEnumMember;
+exports.tSExportAssignment = exports.tsExportAssignment = tsExportAssignment;
+exports.tSExpressionWithTypeArguments = exports.tsExpressionWithTypeArguments = tsExpressionWithTypeArguments;
+exports.tSExternalModuleReference = exports.tsExternalModuleReference = tsExternalModuleReference;
+exports.tSFunctionType = exports.tsFunctionType = tsFunctionType;
+exports.tSImportEqualsDeclaration = exports.tsImportEqualsDeclaration = tsImportEqualsDeclaration;
+exports.tSImportType = exports.tsImportType = tsImportType;
+exports.tSIndexSignature = exports.tsIndexSignature = tsIndexSignature;
+exports.tSIndexedAccessType = exports.tsIndexedAccessType = tsIndexedAccessType;
+exports.tSInferType = exports.tsInferType = tsInferType;
+exports.tSInterfaceBody = exports.tsInterfaceBody = tsInterfaceBody;
+exports.tSInterfaceDeclaration = exports.tsInterfaceDeclaration = tsInterfaceDeclaration;
+exports.tSIntersectionType = exports.tsIntersectionType = tsIntersectionType;
+exports.tSIntrinsicKeyword = exports.tsIntrinsicKeyword = tsIntrinsicKeyword;
+exports.tSLiteralType = exports.tsLiteralType = tsLiteralType;
+exports.tSMappedType = exports.tsMappedType = tsMappedType;
+exports.tSMethodSignature = exports.tsMethodSignature = tsMethodSignature;
+exports.tSModuleBlock = exports.tsModuleBlock = tsModuleBlock;
+exports.tSModuleDeclaration = exports.tsModuleDeclaration = tsModuleDeclaration;
+exports.tSNamedTupleMember = exports.tsNamedTupleMember = tsNamedTupleMember;
+exports.tSNamespaceExportDeclaration = exports.tsNamespaceExportDeclaration = tsNamespaceExportDeclaration;
+exports.tSNeverKeyword = exports.tsNeverKeyword = tsNeverKeyword;
+exports.tSNonNullExpression = exports.tsNonNullExpression = tsNonNullExpression;
+exports.tSNullKeyword = exports.tsNullKeyword = tsNullKeyword;
+exports.tSNumberKeyword = exports.tsNumberKeyword = tsNumberKeyword;
+exports.tSObjectKeyword = exports.tsObjectKeyword = tsObjectKeyword;
+exports.tSOptionalType = exports.tsOptionalType = tsOptionalType;
+exports.tSParameterProperty = exports.tsParameterProperty = tsParameterProperty;
+exports.tSParenthesizedType = exports.tsParenthesizedType = tsParenthesizedType;
+exports.tSPropertySignature = exports.tsPropertySignature = tsPropertySignature;
+exports.tSQualifiedName = exports.tsQualifiedName = tsQualifiedName;
+exports.tSRestType = exports.tsRestType = tsRestType;
+exports.tSStringKeyword = exports.tsStringKeyword = tsStringKeyword;
+exports.tSSymbolKeyword = exports.tsSymbolKeyword = tsSymbolKeyword;
+exports.tSThisType = exports.tsThisType = tsThisType;
+exports.tSTupleType = exports.tsTupleType = tsTupleType;
+exports.tSTypeAliasDeclaration = exports.tsTypeAliasDeclaration = tsTypeAliasDeclaration;
+exports.tSTypeAnnotation = exports.tsTypeAnnotation = tsTypeAnnotation;
+exports.tSTypeAssertion = exports.tsTypeAssertion = tsTypeAssertion;
+exports.tSTypeLiteral = exports.tsTypeLiteral = tsTypeLiteral;
+exports.tSTypeOperator = exports.tsTypeOperator = tsTypeOperator;
+exports.tSTypeParameter = exports.tsTypeParameter = tsTypeParameter;
+exports.tSTypeParameterDeclaration = exports.tsTypeParameterDeclaration = tsTypeParameterDeclaration;
+exports.tSTypeParameterInstantiation = exports.tsTypeParameterInstantiation = tsTypeParameterInstantiation;
+exports.tSTypePredicate = exports.tsTypePredicate = tsTypePredicate;
+exports.tSTypeQuery = exports.tsTypeQuery = tsTypeQuery;
+exports.tSTypeReference = exports.tsTypeReference = tsTypeReference;
+exports.tSUndefinedKeyword = exports.tsUndefinedKeyword = tsUndefinedKeyword;
+exports.tSUnionType = exports.tsUnionType = tsUnionType;
+exports.tSUnknownKeyword = exports.tsUnknownKeyword = tsUnknownKeyword;
+exports.tSVoidKeyword = exports.tsVoidKeyword = tsVoidKeyword;
+exports.tupleExpression = tupleExpression;
+exports.tupleTypeAnnotation = tupleTypeAnnotation;
+exports.typeAlias = typeAlias;
+exports.typeAnnotation = typeAnnotation;
+exports.typeCastExpression = typeCastExpression;
+exports.typeParameter = typeParameter;
+exports.typeParameterDeclaration = typeParameterDeclaration;
+exports.typeParameterInstantiation = typeParameterInstantiation;
+exports.typeofTypeAnnotation = typeofTypeAnnotation;
+exports.unaryExpression = unaryExpression;
+exports.unionTypeAnnotation = unionTypeAnnotation;
+exports.updateExpression = updateExpression;
+exports.v8IntrinsicIdentifier = v8IntrinsicIdentifier;
+exports.variableDeclaration = variableDeclaration;
+exports.variableDeclarator = variableDeclarator;
+exports.variance = variance;
+exports.voidTypeAnnotation = voidTypeAnnotation;
+exports.whileStatement = whileStatement;
+exports.withStatement = withStatement;
+exports.yieldExpression = yieldExpression;
+
+var _builder = require("../builder");
+
+function arrayExpression(elements) {
+ return _builder.default.apply("ArrayExpression", arguments);
+}
+
+function assignmentExpression(operator, left, right) {
+ return _builder.default.apply("AssignmentExpression", arguments);
+}
+
+function binaryExpression(operator, left, right) {
+ return _builder.default.apply("BinaryExpression", arguments);
+}
+
+function interpreterDirective(value) {
+ return _builder.default.apply("InterpreterDirective", arguments);
+}
+
+function directive(value) {
+ return _builder.default.apply("Directive", arguments);
+}
+
+function directiveLiteral(value) {
+ return _builder.default.apply("DirectiveLiteral", arguments);
+}
+
+function blockStatement(body, directives) {
+ return _builder.default.apply("BlockStatement", arguments);
+}
+
+function breakStatement(label) {
+ return _builder.default.apply("BreakStatement", arguments);
+}
+
+function callExpression(callee, _arguments) {
+ return _builder.default.apply("CallExpression", arguments);
+}
+
+function catchClause(param, body) {
+ return _builder.default.apply("CatchClause", arguments);
+}
+
+function conditionalExpression(test, consequent, alternate) {
+ return _builder.default.apply("ConditionalExpression", arguments);
+}
+
+function continueStatement(label) {
+ return _builder.default.apply("ContinueStatement", arguments);
+}
+
+function debuggerStatement() {
+ return _builder.default.apply("DebuggerStatement", arguments);
+}
+
+function doWhileStatement(test, body) {
+ return _builder.default.apply("DoWhileStatement", arguments);
+}
+
+function emptyStatement() {
+ return _builder.default.apply("EmptyStatement", arguments);
+}
+
+function expressionStatement(expression) {
+ return _builder.default.apply("ExpressionStatement", arguments);
+}
+
+function file(program, comments, tokens) {
+ return _builder.default.apply("File", arguments);
+}
+
+function forInStatement(left, right, body) {
+ return _builder.default.apply("ForInStatement", arguments);
+}
+
+function forStatement(init, test, update, body) {
+ return _builder.default.apply("ForStatement", arguments);
+}
+
+function functionDeclaration(id, params, body, generator, async) {
+ return _builder.default.apply("FunctionDeclaration", arguments);
+}
+
+function functionExpression(id, params, body, generator, async) {
+ return _builder.default.apply("FunctionExpression", arguments);
+}
+
+function identifier(name) {
+ return _builder.default.apply("Identifier", arguments);
+}
+
+function ifStatement(test, consequent, alternate) {
+ return _builder.default.apply("IfStatement", arguments);
+}
+
+function labeledStatement(label, body) {
+ return _builder.default.apply("LabeledStatement", arguments);
+}
+
+function stringLiteral(value) {
+ return _builder.default.apply("StringLiteral", arguments);
+}
+
+function numericLiteral(value) {
+ return _builder.default.apply("NumericLiteral", arguments);
+}
+
+function nullLiteral() {
+ return _builder.default.apply("NullLiteral", arguments);
+}
+
+function booleanLiteral(value) {
+ return _builder.default.apply("BooleanLiteral", arguments);
+}
+
+function regExpLiteral(pattern, flags) {
+ return _builder.default.apply("RegExpLiteral", arguments);
+}
+
+function logicalExpression(operator, left, right) {
+ return _builder.default.apply("LogicalExpression", arguments);
+}
+
+function memberExpression(object, property, computed, optional) {
+ return _builder.default.apply("MemberExpression", arguments);
+}
+
+function newExpression(callee, _arguments) {
+ return _builder.default.apply("NewExpression", arguments);
+}
+
+function program(body, directives, sourceType, interpreter) {
+ return _builder.default.apply("Program", arguments);
+}
+
+function objectExpression(properties) {
+ return _builder.default.apply("ObjectExpression", arguments);
+}
+
+function objectMethod(kind, key, params, body, computed, generator, async) {
+ return _builder.default.apply("ObjectMethod", arguments);
+}
+
+function objectProperty(key, value, computed, shorthand, decorators) {
+ return _builder.default.apply("ObjectProperty", arguments);
+}
+
+function restElement(argument) {
+ return _builder.default.apply("RestElement", arguments);
+}
+
+function returnStatement(argument) {
+ return _builder.default.apply("ReturnStatement", arguments);
+}
+
+function sequenceExpression(expressions) {
+ return _builder.default.apply("SequenceExpression", arguments);
+}
+
+function parenthesizedExpression(expression) {
+ return _builder.default.apply("ParenthesizedExpression", arguments);
+}
+
+function switchCase(test, consequent) {
+ return _builder.default.apply("SwitchCase", arguments);
+}
+
+function switchStatement(discriminant, cases) {
+ return _builder.default.apply("SwitchStatement", arguments);
+}
+
+function thisExpression() {
+ return _builder.default.apply("ThisExpression", arguments);
+}
+
+function throwStatement(argument) {
+ return _builder.default.apply("ThrowStatement", arguments);
+}
+
+function tryStatement(block, handler, finalizer) {
+ return _builder.default.apply("TryStatement", arguments);
+}
+
+function unaryExpression(operator, argument, prefix) {
+ return _builder.default.apply("UnaryExpression", arguments);
+}
+
+function updateExpression(operator, argument, prefix) {
+ return _builder.default.apply("UpdateExpression", arguments);
+}
+
+function variableDeclaration(kind, declarations) {
+ return _builder.default.apply("VariableDeclaration", arguments);
+}
+
+function variableDeclarator(id, init) {
+ return _builder.default.apply("VariableDeclarator", arguments);
+}
+
+function whileStatement(test, body) {
+ return _builder.default.apply("WhileStatement", arguments);
+}
+
+function withStatement(object, body) {
+ return _builder.default.apply("WithStatement", arguments);
+}
+
+function assignmentPattern(left, right) {
+ return _builder.default.apply("AssignmentPattern", arguments);
+}
+
+function arrayPattern(elements) {
+ return _builder.default.apply("ArrayPattern", arguments);
+}
+
+function arrowFunctionExpression(params, body, async) {
+ return _builder.default.apply("ArrowFunctionExpression", arguments);
+}
+
+function classBody(body) {
+ return _builder.default.apply("ClassBody", arguments);
+}
+
+function classExpression(id, superClass, body, decorators) {
+ return _builder.default.apply("ClassExpression", arguments);
+}
+
+function classDeclaration(id, superClass, body, decorators) {
+ return _builder.default.apply("ClassDeclaration", arguments);
+}
+
+function exportAllDeclaration(source) {
+ return _builder.default.apply("ExportAllDeclaration", arguments);
+}
+
+function exportDefaultDeclaration(declaration) {
+ return _builder.default.apply("ExportDefaultDeclaration", arguments);
+}
+
+function exportNamedDeclaration(declaration, specifiers, source) {
+ return _builder.default.apply("ExportNamedDeclaration", arguments);
+}
+
+function exportSpecifier(local, exported) {
+ return _builder.default.apply("ExportSpecifier", arguments);
+}
+
+function forOfStatement(left, right, body, _await) {
+ return _builder.default.apply("ForOfStatement", arguments);
+}
+
+function importDeclaration(specifiers, source) {
+ return _builder.default.apply("ImportDeclaration", arguments);
+}
+
+function importDefaultSpecifier(local) {
+ return _builder.default.apply("ImportDefaultSpecifier", arguments);
+}
+
+function importNamespaceSpecifier(local) {
+ return _builder.default.apply("ImportNamespaceSpecifier", arguments);
+}
+
+function importSpecifier(local, imported) {
+ return _builder.default.apply("ImportSpecifier", arguments);
+}
+
+function metaProperty(meta, property) {
+ return _builder.default.apply("MetaProperty", arguments);
+}
+
+function classMethod(kind, key, params, body, computed, _static, generator, async) {
+ return _builder.default.apply("ClassMethod", arguments);
+}
+
+function objectPattern(properties) {
+ return _builder.default.apply("ObjectPattern", arguments);
+}
+
+function spreadElement(argument) {
+ return _builder.default.apply("SpreadElement", arguments);
+}
+
+function _super() {
+ return _builder.default.apply("Super", arguments);
+}
+
+function taggedTemplateExpression(tag, quasi) {
+ return _builder.default.apply("TaggedTemplateExpression", arguments);
+}
+
+function templateElement(value, tail) {
+ return _builder.default.apply("TemplateElement", arguments);
+}
+
+function templateLiteral(quasis, expressions) {
+ return _builder.default.apply("TemplateLiteral", arguments);
+}
+
+function yieldExpression(argument, delegate) {
+ return _builder.default.apply("YieldExpression", arguments);
+}
+
+function awaitExpression(argument) {
+ return _builder.default.apply("AwaitExpression", arguments);
+}
+
+function _import() {
+ return _builder.default.apply("Import", arguments);
+}
+
+function bigIntLiteral(value) {
+ return _builder.default.apply("BigIntLiteral", arguments);
+}
+
+function exportNamespaceSpecifier(exported) {
+ return _builder.default.apply("ExportNamespaceSpecifier", arguments);
+}
+
+function optionalMemberExpression(object, property, computed, optional) {
+ return _builder.default.apply("OptionalMemberExpression", arguments);
+}
+
+function optionalCallExpression(callee, _arguments, optional) {
+ return _builder.default.apply("OptionalCallExpression", arguments);
+}
+
+function classProperty(key, value, typeAnnotation, decorators, computed, _static) {
+ return _builder.default.apply("ClassProperty", arguments);
+}
+
+function classAccessorProperty(key, value, typeAnnotation, decorators, computed, _static) {
+ return _builder.default.apply("ClassAccessorProperty", arguments);
+}
+
+function classPrivateProperty(key, value, decorators, _static) {
+ return _builder.default.apply("ClassPrivateProperty", arguments);
+}
+
+function classPrivateMethod(kind, key, params, body, _static) {
+ return _builder.default.apply("ClassPrivateMethod", arguments);
+}
+
+function privateName(id) {
+ return _builder.default.apply("PrivateName", arguments);
+}
+
+function staticBlock(body) {
+ return _builder.default.apply("StaticBlock", arguments);
+}
+
+function anyTypeAnnotation() {
+ return _builder.default.apply("AnyTypeAnnotation", arguments);
+}
+
+function arrayTypeAnnotation(elementType) {
+ return _builder.default.apply("ArrayTypeAnnotation", arguments);
+}
+
+function booleanTypeAnnotation() {
+ return _builder.default.apply("BooleanTypeAnnotation", arguments);
+}
+
+function booleanLiteralTypeAnnotation(value) {
+ return _builder.default.apply("BooleanLiteralTypeAnnotation", arguments);
+}
+
+function nullLiteralTypeAnnotation() {
+ return _builder.default.apply("NullLiteralTypeAnnotation", arguments);
+}
+
+function classImplements(id, typeParameters) {
+ return _builder.default.apply("ClassImplements", arguments);
+}
+
+function declareClass(id, typeParameters, _extends, body) {
+ return _builder.default.apply("DeclareClass", arguments);
+}
+
+function declareFunction(id) {
+ return _builder.default.apply("DeclareFunction", arguments);
+}
+
+function declareInterface(id, typeParameters, _extends, body) {
+ return _builder.default.apply("DeclareInterface", arguments);
+}
+
+function declareModule(id, body, kind) {
+ return _builder.default.apply("DeclareModule", arguments);
+}
+
+function declareModuleExports(typeAnnotation) {
+ return _builder.default.apply("DeclareModuleExports", arguments);
+}
+
+function declareTypeAlias(id, typeParameters, right) {
+ return _builder.default.apply("DeclareTypeAlias", arguments);
+}
+
+function declareOpaqueType(id, typeParameters, supertype) {
+ return _builder.default.apply("DeclareOpaqueType", arguments);
+}
+
+function declareVariable(id) {
+ return _builder.default.apply("DeclareVariable", arguments);
+}
+
+function declareExportDeclaration(declaration, specifiers, source) {
+ return _builder.default.apply("DeclareExportDeclaration", arguments);
+}
+
+function declareExportAllDeclaration(source) {
+ return _builder.default.apply("DeclareExportAllDeclaration", arguments);
+}
+
+function declaredPredicate(value) {
+ return _builder.default.apply("DeclaredPredicate", arguments);
+}
+
+function existsTypeAnnotation() {
+ return _builder.default.apply("ExistsTypeAnnotation", arguments);
+}
+
+function functionTypeAnnotation(typeParameters, params, rest, returnType) {
+ return _builder.default.apply("FunctionTypeAnnotation", arguments);
+}
+
+function functionTypeParam(name, typeAnnotation) {
+ return _builder.default.apply("FunctionTypeParam", arguments);
+}
+
+function genericTypeAnnotation(id, typeParameters) {
+ return _builder.default.apply("GenericTypeAnnotation", arguments);
+}
+
+function inferredPredicate() {
+ return _builder.default.apply("InferredPredicate", arguments);
+}
+
+function interfaceExtends(id, typeParameters) {
+ return _builder.default.apply("InterfaceExtends", arguments);
+}
+
+function interfaceDeclaration(id, typeParameters, _extends, body) {
+ return _builder.default.apply("InterfaceDeclaration", arguments);
+}
+
+function interfaceTypeAnnotation(_extends, body) {
+ return _builder.default.apply("InterfaceTypeAnnotation", arguments);
+}
+
+function intersectionTypeAnnotation(types) {
+ return _builder.default.apply("IntersectionTypeAnnotation", arguments);
+}
+
+function mixedTypeAnnotation() {
+ return _builder.default.apply("MixedTypeAnnotation", arguments);
+}
+
+function emptyTypeAnnotation() {
+ return _builder.default.apply("EmptyTypeAnnotation", arguments);
+}
+
+function nullableTypeAnnotation(typeAnnotation) {
+ return _builder.default.apply("NullableTypeAnnotation", arguments);
+}
+
+function numberLiteralTypeAnnotation(value) {
+ return _builder.default.apply("NumberLiteralTypeAnnotation", arguments);
+}
+
+function numberTypeAnnotation() {
+ return _builder.default.apply("NumberTypeAnnotation", arguments);
+}
+
+function objectTypeAnnotation(properties, indexers, callProperties, internalSlots, exact) {
+ return _builder.default.apply("ObjectTypeAnnotation", arguments);
+}
+
+function objectTypeInternalSlot(id, value, optional, _static, method) {
+ return _builder.default.apply("ObjectTypeInternalSlot", arguments);
+}
+
+function objectTypeCallProperty(value) {
+ return _builder.default.apply("ObjectTypeCallProperty", arguments);
+}
+
+function objectTypeIndexer(id, key, value, variance) {
+ return _builder.default.apply("ObjectTypeIndexer", arguments);
+}
+
+function objectTypeProperty(key, value, variance) {
+ return _builder.default.apply("ObjectTypeProperty", arguments);
+}
+
+function objectTypeSpreadProperty(argument) {
+ return _builder.default.apply("ObjectTypeSpreadProperty", arguments);
+}
+
+function opaqueType(id, typeParameters, supertype, impltype) {
+ return _builder.default.apply("OpaqueType", arguments);
+}
+
+function qualifiedTypeIdentifier(id, qualification) {
+ return _builder.default.apply("QualifiedTypeIdentifier", arguments);
+}
+
+function stringLiteralTypeAnnotation(value) {
+ return _builder.default.apply("StringLiteralTypeAnnotation", arguments);
+}
+
+function stringTypeAnnotation() {
+ return _builder.default.apply("StringTypeAnnotation", arguments);
+}
+
+function symbolTypeAnnotation() {
+ return _builder.default.apply("SymbolTypeAnnotation", arguments);
+}
+
+function thisTypeAnnotation() {
+ return _builder.default.apply("ThisTypeAnnotation", arguments);
+}
+
+function tupleTypeAnnotation(types) {
+ return _builder.default.apply("TupleTypeAnnotation", arguments);
+}
+
+function typeofTypeAnnotation(argument) {
+ return _builder.default.apply("TypeofTypeAnnotation", arguments);
+}
+
+function typeAlias(id, typeParameters, right) {
+ return _builder.default.apply("TypeAlias", arguments);
+}
+
+function typeAnnotation(typeAnnotation) {
+ return _builder.default.apply("TypeAnnotation", arguments);
+}
+
+function typeCastExpression(expression, typeAnnotation) {
+ return _builder.default.apply("TypeCastExpression", arguments);
+}
+
+function typeParameter(bound, _default, variance) {
+ return _builder.default.apply("TypeParameter", arguments);
+}
+
+function typeParameterDeclaration(params) {
+ return _builder.default.apply("TypeParameterDeclaration", arguments);
+}
+
+function typeParameterInstantiation(params) {
+ return _builder.default.apply("TypeParameterInstantiation", arguments);
+}
+
+function unionTypeAnnotation(types) {
+ return _builder.default.apply("UnionTypeAnnotation", arguments);
+}
+
+function variance(kind) {
+ return _builder.default.apply("Variance", arguments);
+}
+
+function voidTypeAnnotation() {
+ return _builder.default.apply("VoidTypeAnnotation", arguments);
+}
+
+function enumDeclaration(id, body) {
+ return _builder.default.apply("EnumDeclaration", arguments);
+}
+
+function enumBooleanBody(members) {
+ return _builder.default.apply("EnumBooleanBody", arguments);
+}
+
+function enumNumberBody(members) {
+ return _builder.default.apply("EnumNumberBody", arguments);
+}
+
+function enumStringBody(members) {
+ return _builder.default.apply("EnumStringBody", arguments);
+}
+
+function enumSymbolBody(members) {
+ return _builder.default.apply("EnumSymbolBody", arguments);
+}
+
+function enumBooleanMember(id) {
+ return _builder.default.apply("EnumBooleanMember", arguments);
+}
+
+function enumNumberMember(id, init) {
+ return _builder.default.apply("EnumNumberMember", arguments);
+}
+
+function enumStringMember(id, init) {
+ return _builder.default.apply("EnumStringMember", arguments);
+}
+
+function enumDefaultedMember(id) {
+ return _builder.default.apply("EnumDefaultedMember", arguments);
+}
+
+function indexedAccessType(objectType, indexType) {
+ return _builder.default.apply("IndexedAccessType", arguments);
+}
+
+function optionalIndexedAccessType(objectType, indexType) {
+ return _builder.default.apply("OptionalIndexedAccessType", arguments);
+}
+
+function jsxAttribute(name, value) {
+ return _builder.default.apply("JSXAttribute", arguments);
+}
+
+function jsxClosingElement(name) {
+ return _builder.default.apply("JSXClosingElement", arguments);
+}
+
+function jsxElement(openingElement, closingElement, children, selfClosing) {
+ return _builder.default.apply("JSXElement", arguments);
+}
+
+function jsxEmptyExpression() {
+ return _builder.default.apply("JSXEmptyExpression", arguments);
+}
+
+function jsxExpressionContainer(expression) {
+ return _builder.default.apply("JSXExpressionContainer", arguments);
+}
+
+function jsxSpreadChild(expression) {
+ return _builder.default.apply("JSXSpreadChild", arguments);
+}
+
+function jsxIdentifier(name) {
+ return _builder.default.apply("JSXIdentifier", arguments);
+}
+
+function jsxMemberExpression(object, property) {
+ return _builder.default.apply("JSXMemberExpression", arguments);
+}
+
+function jsxNamespacedName(namespace, name) {
+ return _builder.default.apply("JSXNamespacedName", arguments);
+}
+
+function jsxOpeningElement(name, attributes, selfClosing) {
+ return _builder.default.apply("JSXOpeningElement", arguments);
+}
+
+function jsxSpreadAttribute(argument) {
+ return _builder.default.apply("JSXSpreadAttribute", arguments);
+}
+
+function jsxText(value) {
+ return _builder.default.apply("JSXText", arguments);
+}
+
+function jsxFragment(openingFragment, closingFragment, children) {
+ return _builder.default.apply("JSXFragment", arguments);
+}
+
+function jsxOpeningFragment() {
+ return _builder.default.apply("JSXOpeningFragment", arguments);
+}
+
+function jsxClosingFragment() {
+ return _builder.default.apply("JSXClosingFragment", arguments);
+}
+
+function noop() {
+ return _builder.default.apply("Noop", arguments);
+}
+
+function placeholder(expectedNode, name) {
+ return _builder.default.apply("Placeholder", arguments);
+}
+
+function v8IntrinsicIdentifier(name) {
+ return _builder.default.apply("V8IntrinsicIdentifier", arguments);
+}
+
+function argumentPlaceholder() {
+ return _builder.default.apply("ArgumentPlaceholder", arguments);
+}
+
+function bindExpression(object, callee) {
+ return _builder.default.apply("BindExpression", arguments);
+}
+
+function importAttribute(key, value) {
+ return _builder.default.apply("ImportAttribute", arguments);
+}
+
+function decorator(expression) {
+ return _builder.default.apply("Decorator", arguments);
+}
+
+function doExpression(body, async) {
+ return _builder.default.apply("DoExpression", arguments);
+}
+
+function exportDefaultSpecifier(exported) {
+ return _builder.default.apply("ExportDefaultSpecifier", arguments);
+}
+
+function recordExpression(properties) {
+ return _builder.default.apply("RecordExpression", arguments);
+}
+
+function tupleExpression(elements) {
+ return _builder.default.apply("TupleExpression", arguments);
+}
+
+function decimalLiteral(value) {
+ return _builder.default.apply("DecimalLiteral", arguments);
+}
+
+function moduleExpression(body) {
+ return _builder.default.apply("ModuleExpression", arguments);
+}
+
+function topicReference() {
+ return _builder.default.apply("TopicReference", arguments);
+}
+
+function pipelineTopicExpression(expression) {
+ return _builder.default.apply("PipelineTopicExpression", arguments);
+}
+
+function pipelineBareFunction(callee) {
+ return _builder.default.apply("PipelineBareFunction", arguments);
+}
+
+function pipelinePrimaryTopicReference() {
+ return _builder.default.apply("PipelinePrimaryTopicReference", arguments);
+}
+
+function tsParameterProperty(parameter) {
+ return _builder.default.apply("TSParameterProperty", arguments);
+}
+
+function tsDeclareFunction(id, typeParameters, params, returnType) {
+ return _builder.default.apply("TSDeclareFunction", arguments);
+}
+
+function tsDeclareMethod(decorators, key, typeParameters, params, returnType) {
+ return _builder.default.apply("TSDeclareMethod", arguments);
+}
+
+function tsQualifiedName(left, right) {
+ return _builder.default.apply("TSQualifiedName", arguments);
+}
+
+function tsCallSignatureDeclaration(typeParameters, parameters, typeAnnotation) {
+ return _builder.default.apply("TSCallSignatureDeclaration", arguments);
+}
+
+function tsConstructSignatureDeclaration(typeParameters, parameters, typeAnnotation) {
+ return _builder.default.apply("TSConstructSignatureDeclaration", arguments);
+}
+
+function tsPropertySignature(key, typeAnnotation, initializer) {
+ return _builder.default.apply("TSPropertySignature", arguments);
+}
+
+function tsMethodSignature(key, typeParameters, parameters, typeAnnotation) {
+ return _builder.default.apply("TSMethodSignature", arguments);
+}
+
+function tsIndexSignature(parameters, typeAnnotation) {
+ return _builder.default.apply("TSIndexSignature", arguments);
+}
+
+function tsAnyKeyword() {
+ return _builder.default.apply("TSAnyKeyword", arguments);
+}
+
+function tsBooleanKeyword() {
+ return _builder.default.apply("TSBooleanKeyword", arguments);
+}
+
+function tsBigIntKeyword() {
+ return _builder.default.apply("TSBigIntKeyword", arguments);
+}
+
+function tsIntrinsicKeyword() {
+ return _builder.default.apply("TSIntrinsicKeyword", arguments);
+}
+
+function tsNeverKeyword() {
+ return _builder.default.apply("TSNeverKeyword", arguments);
+}
+
+function tsNullKeyword() {
+ return _builder.default.apply("TSNullKeyword", arguments);
+}
+
+function tsNumberKeyword() {
+ return _builder.default.apply("TSNumberKeyword", arguments);
+}
+
+function tsObjectKeyword() {
+ return _builder.default.apply("TSObjectKeyword", arguments);
+}
+
+function tsStringKeyword() {
+ return _builder.default.apply("TSStringKeyword", arguments);
+}
+
+function tsSymbolKeyword() {
+ return _builder.default.apply("TSSymbolKeyword", arguments);
+}
+
+function tsUndefinedKeyword() {
+ return _builder.default.apply("TSUndefinedKeyword", arguments);
+}
+
+function tsUnknownKeyword() {
+ return _builder.default.apply("TSUnknownKeyword", arguments);
+}
+
+function tsVoidKeyword() {
+ return _builder.default.apply("TSVoidKeyword", arguments);
+}
+
+function tsThisType() {
+ return _builder.default.apply("TSThisType", arguments);
+}
+
+function tsFunctionType(typeParameters, parameters, typeAnnotation) {
+ return _builder.default.apply("TSFunctionType", arguments);
+}
+
+function tsConstructorType(typeParameters, parameters, typeAnnotation) {
+ return _builder.default.apply("TSConstructorType", arguments);
+}
+
+function tsTypeReference(typeName, typeParameters) {
+ return _builder.default.apply("TSTypeReference", arguments);
+}
+
+function tsTypePredicate(parameterName, typeAnnotation, asserts) {
+ return _builder.default.apply("TSTypePredicate", arguments);
+}
+
+function tsTypeQuery(exprName) {
+ return _builder.default.apply("TSTypeQuery", arguments);
+}
+
+function tsTypeLiteral(members) {
+ return _builder.default.apply("TSTypeLiteral", arguments);
+}
+
+function tsArrayType(elementType) {
+ return _builder.default.apply("TSArrayType", arguments);
+}
+
+function tsTupleType(elementTypes) {
+ return _builder.default.apply("TSTupleType", arguments);
+}
+
+function tsOptionalType(typeAnnotation) {
+ return _builder.default.apply("TSOptionalType", arguments);
+}
+
+function tsRestType(typeAnnotation) {
+ return _builder.default.apply("TSRestType", arguments);
+}
+
+function tsNamedTupleMember(label, elementType, optional) {
+ return _builder.default.apply("TSNamedTupleMember", arguments);
+}
+
+function tsUnionType(types) {
+ return _builder.default.apply("TSUnionType", arguments);
+}
+
+function tsIntersectionType(types) {
+ return _builder.default.apply("TSIntersectionType", arguments);
+}
+
+function tsConditionalType(checkType, extendsType, trueType, falseType) {
+ return _builder.default.apply("TSConditionalType", arguments);
+}
+
+function tsInferType(typeParameter) {
+ return _builder.default.apply("TSInferType", arguments);
+}
+
+function tsParenthesizedType(typeAnnotation) {
+ return _builder.default.apply("TSParenthesizedType", arguments);
+}
+
+function tsTypeOperator(typeAnnotation) {
+ return _builder.default.apply("TSTypeOperator", arguments);
+}
+
+function tsIndexedAccessType(objectType, indexType) {
+ return _builder.default.apply("TSIndexedAccessType", arguments);
+}
+
+function tsMappedType(typeParameter, typeAnnotation, nameType) {
+ return _builder.default.apply("TSMappedType", arguments);
+}
+
+function tsLiteralType(literal) {
+ return _builder.default.apply("TSLiteralType", arguments);
+}
+
+function tsExpressionWithTypeArguments(expression, typeParameters) {
+ return _builder.default.apply("TSExpressionWithTypeArguments", arguments);
+}
+
+function tsInterfaceDeclaration(id, typeParameters, _extends, body) {
+ return _builder.default.apply("TSInterfaceDeclaration", arguments);
+}
+
+function tsInterfaceBody(body) {
+ return _builder.default.apply("TSInterfaceBody", arguments);
+}
+
+function tsTypeAliasDeclaration(id, typeParameters, typeAnnotation) {
+ return _builder.default.apply("TSTypeAliasDeclaration", arguments);
+}
+
+function tsAsExpression(expression, typeAnnotation) {
+ return _builder.default.apply("TSAsExpression", arguments);
+}
+
+function tsTypeAssertion(typeAnnotation, expression) {
+ return _builder.default.apply("TSTypeAssertion", arguments);
+}
+
+function tsEnumDeclaration(id, members) {
+ return _builder.default.apply("TSEnumDeclaration", arguments);
+}
+
+function tsEnumMember(id, initializer) {
+ return _builder.default.apply("TSEnumMember", arguments);
+}
+
+function tsModuleDeclaration(id, body) {
+ return _builder.default.apply("TSModuleDeclaration", arguments);
+}
+
+function tsModuleBlock(body) {
+ return _builder.default.apply("TSModuleBlock", arguments);
+}
+
+function tsImportType(argument, qualifier, typeParameters) {
+ return _builder.default.apply("TSImportType", arguments);
+}
+
+function tsImportEqualsDeclaration(id, moduleReference) {
+ return _builder.default.apply("TSImportEqualsDeclaration", arguments);
+}
+
+function tsExternalModuleReference(expression) {
+ return _builder.default.apply("TSExternalModuleReference", arguments);
+}
+
+function tsNonNullExpression(expression) {
+ return _builder.default.apply("TSNonNullExpression", arguments);
+}
+
+function tsExportAssignment(expression) {
+ return _builder.default.apply("TSExportAssignment", arguments);
+}
+
+function tsNamespaceExportDeclaration(id) {
+ return _builder.default.apply("TSNamespaceExportDeclaration", arguments);
+}
+
+function tsTypeAnnotation(typeAnnotation) {
+ return _builder.default.apply("TSTypeAnnotation", arguments);
+}
+
+function tsTypeParameterInstantiation(params) {
+ return _builder.default.apply("TSTypeParameterInstantiation", arguments);
+}
+
+function tsTypeParameterDeclaration(params) {
+ return _builder.default.apply("TSTypeParameterDeclaration", arguments);
+}
+
+function tsTypeParameter(constraint, _default, name) {
+ return _builder.default.apply("TSTypeParameter", arguments);
+}
+
+function NumberLiteral(value) {
+ console.trace("The node type NumberLiteral has been renamed to NumericLiteral");
+ return _builder.default.apply("NumberLiteral", arguments);
+}
+
+function RegexLiteral(pattern, flags) {
+ console.trace("The node type RegexLiteral has been renamed to RegExpLiteral");
+ return _builder.default.apply("RegexLiteral", arguments);
+}
+
+function RestProperty(argument) {
+ console.trace("The node type RestProperty has been renamed to RestElement");
+ return _builder.default.apply("RestProperty", arguments);
+}
+
+function SpreadProperty(argument) {
+ console.trace("The node type SpreadProperty has been renamed to SpreadElement");
+ return _builder.default.apply("SpreadProperty", arguments);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/builders/generated/uppercase.js b/node_modules/@babel/types/lib/builders/generated/uppercase.js
new file mode 100644
index 000000000..95c9a5258
--- /dev/null
+++ b/node_modules/@babel/types/lib/builders/generated/uppercase.js
@@ -0,0 +1,1513 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+Object.defineProperty(exports, "AnyTypeAnnotation", {
+ enumerable: true,
+ get: function () {
+ return _index.anyTypeAnnotation;
+ }
+});
+Object.defineProperty(exports, "ArgumentPlaceholder", {
+ enumerable: true,
+ get: function () {
+ return _index.argumentPlaceholder;
+ }
+});
+Object.defineProperty(exports, "ArrayExpression", {
+ enumerable: true,
+ get: function () {
+ return _index.arrayExpression;
+ }
+});
+Object.defineProperty(exports, "ArrayPattern", {
+ enumerable: true,
+ get: function () {
+ return _index.arrayPattern;
+ }
+});
+Object.defineProperty(exports, "ArrayTypeAnnotation", {
+ enumerable: true,
+ get: function () {
+ return _index.arrayTypeAnnotation;
+ }
+});
+Object.defineProperty(exports, "ArrowFunctionExpression", {
+ enumerable: true,
+ get: function () {
+ return _index.arrowFunctionExpression;
+ }
+});
+Object.defineProperty(exports, "AssignmentExpression", {
+ enumerable: true,
+ get: function () {
+ return _index.assignmentExpression;
+ }
+});
+Object.defineProperty(exports, "AssignmentPattern", {
+ enumerable: true,
+ get: function () {
+ return _index.assignmentPattern;
+ }
+});
+Object.defineProperty(exports, "AwaitExpression", {
+ enumerable: true,
+ get: function () {
+ return _index.awaitExpression;
+ }
+});
+Object.defineProperty(exports, "BigIntLiteral", {
+ enumerable: true,
+ get: function () {
+ return _index.bigIntLiteral;
+ }
+});
+Object.defineProperty(exports, "BinaryExpression", {
+ enumerable: true,
+ get: function () {
+ return _index.binaryExpression;
+ }
+});
+Object.defineProperty(exports, "BindExpression", {
+ enumerable: true,
+ get: function () {
+ return _index.bindExpression;
+ }
+});
+Object.defineProperty(exports, "BlockStatement", {
+ enumerable: true,
+ get: function () {
+ return _index.blockStatement;
+ }
+});
+Object.defineProperty(exports, "BooleanLiteral", {
+ enumerable: true,
+ get: function () {
+ return _index.booleanLiteral;
+ }
+});
+Object.defineProperty(exports, "BooleanLiteralTypeAnnotation", {
+ enumerable: true,
+ get: function () {
+ return _index.booleanLiteralTypeAnnotation;
+ }
+});
+Object.defineProperty(exports, "BooleanTypeAnnotation", {
+ enumerable: true,
+ get: function () {
+ return _index.booleanTypeAnnotation;
+ }
+});
+Object.defineProperty(exports, "BreakStatement", {
+ enumerable: true,
+ get: function () {
+ return _index.breakStatement;
+ }
+});
+Object.defineProperty(exports, "CallExpression", {
+ enumerable: true,
+ get: function () {
+ return _index.callExpression;
+ }
+});
+Object.defineProperty(exports, "CatchClause", {
+ enumerable: true,
+ get: function () {
+ return _index.catchClause;
+ }
+});
+Object.defineProperty(exports, "ClassAccessorProperty", {
+ enumerable: true,
+ get: function () {
+ return _index.classAccessorProperty;
+ }
+});
+Object.defineProperty(exports, "ClassBody", {
+ enumerable: true,
+ get: function () {
+ return _index.classBody;
+ }
+});
+Object.defineProperty(exports, "ClassDeclaration", {
+ enumerable: true,
+ get: function () {
+ return _index.classDeclaration;
+ }
+});
+Object.defineProperty(exports, "ClassExpression", {
+ enumerable: true,
+ get: function () {
+ return _index.classExpression;
+ }
+});
+Object.defineProperty(exports, "ClassImplements", {
+ enumerable: true,
+ get: function () {
+ return _index.classImplements;
+ }
+});
+Object.defineProperty(exports, "ClassMethod", {
+ enumerable: true,
+ get: function () {
+ return _index.classMethod;
+ }
+});
+Object.defineProperty(exports, "ClassPrivateMethod", {
+ enumerable: true,
+ get: function () {
+ return _index.classPrivateMethod;
+ }
+});
+Object.defineProperty(exports, "ClassPrivateProperty", {
+ enumerable: true,
+ get: function () {
+ return _index.classPrivateProperty;
+ }
+});
+Object.defineProperty(exports, "ClassProperty", {
+ enumerable: true,
+ get: function () {
+ return _index.classProperty;
+ }
+});
+Object.defineProperty(exports, "ConditionalExpression", {
+ enumerable: true,
+ get: function () {
+ return _index.conditionalExpression;
+ }
+});
+Object.defineProperty(exports, "ContinueStatement", {
+ enumerable: true,
+ get: function () {
+ return _index.continueStatement;
+ }
+});
+Object.defineProperty(exports, "DebuggerStatement", {
+ enumerable: true,
+ get: function () {
+ return _index.debuggerStatement;
+ }
+});
+Object.defineProperty(exports, "DecimalLiteral", {
+ enumerable: true,
+ get: function () {
+ return _index.decimalLiteral;
+ }
+});
+Object.defineProperty(exports, "DeclareClass", {
+ enumerable: true,
+ get: function () {
+ return _index.declareClass;
+ }
+});
+Object.defineProperty(exports, "DeclareExportAllDeclaration", {
+ enumerable: true,
+ get: function () {
+ return _index.declareExportAllDeclaration;
+ }
+});
+Object.defineProperty(exports, "DeclareExportDeclaration", {
+ enumerable: true,
+ get: function () {
+ return _index.declareExportDeclaration;
+ }
+});
+Object.defineProperty(exports, "DeclareFunction", {
+ enumerable: true,
+ get: function () {
+ return _index.declareFunction;
+ }
+});
+Object.defineProperty(exports, "DeclareInterface", {
+ enumerable: true,
+ get: function () {
+ return _index.declareInterface;
+ }
+});
+Object.defineProperty(exports, "DeclareModule", {
+ enumerable: true,
+ get: function () {
+ return _index.declareModule;
+ }
+});
+Object.defineProperty(exports, "DeclareModuleExports", {
+ enumerable: true,
+ get: function () {
+ return _index.declareModuleExports;
+ }
+});
+Object.defineProperty(exports, "DeclareOpaqueType", {
+ enumerable: true,
+ get: function () {
+ return _index.declareOpaqueType;
+ }
+});
+Object.defineProperty(exports, "DeclareTypeAlias", {
+ enumerable: true,
+ get: function () {
+ return _index.declareTypeAlias;
+ }
+});
+Object.defineProperty(exports, "DeclareVariable", {
+ enumerable: true,
+ get: function () {
+ return _index.declareVariable;
+ }
+});
+Object.defineProperty(exports, "DeclaredPredicate", {
+ enumerable: true,
+ get: function () {
+ return _index.declaredPredicate;
+ }
+});
+Object.defineProperty(exports, "Decorator", {
+ enumerable: true,
+ get: function () {
+ return _index.decorator;
+ }
+});
+Object.defineProperty(exports, "Directive", {
+ enumerable: true,
+ get: function () {
+ return _index.directive;
+ }
+});
+Object.defineProperty(exports, "DirectiveLiteral", {
+ enumerable: true,
+ get: function () {
+ return _index.directiveLiteral;
+ }
+});
+Object.defineProperty(exports, "DoExpression", {
+ enumerable: true,
+ get: function () {
+ return _index.doExpression;
+ }
+});
+Object.defineProperty(exports, "DoWhileStatement", {
+ enumerable: true,
+ get: function () {
+ return _index.doWhileStatement;
+ }
+});
+Object.defineProperty(exports, "EmptyStatement", {
+ enumerable: true,
+ get: function () {
+ return _index.emptyStatement;
+ }
+});
+Object.defineProperty(exports, "EmptyTypeAnnotation", {
+ enumerable: true,
+ get: function () {
+ return _index.emptyTypeAnnotation;
+ }
+});
+Object.defineProperty(exports, "EnumBooleanBody", {
+ enumerable: true,
+ get: function () {
+ return _index.enumBooleanBody;
+ }
+});
+Object.defineProperty(exports, "EnumBooleanMember", {
+ enumerable: true,
+ get: function () {
+ return _index.enumBooleanMember;
+ }
+});
+Object.defineProperty(exports, "EnumDeclaration", {
+ enumerable: true,
+ get: function () {
+ return _index.enumDeclaration;
+ }
+});
+Object.defineProperty(exports, "EnumDefaultedMember", {
+ enumerable: true,
+ get: function () {
+ return _index.enumDefaultedMember;
+ }
+});
+Object.defineProperty(exports, "EnumNumberBody", {
+ enumerable: true,
+ get: function () {
+ return _index.enumNumberBody;
+ }
+});
+Object.defineProperty(exports, "EnumNumberMember", {
+ enumerable: true,
+ get: function () {
+ return _index.enumNumberMember;
+ }
+});
+Object.defineProperty(exports, "EnumStringBody", {
+ enumerable: true,
+ get: function () {
+ return _index.enumStringBody;
+ }
+});
+Object.defineProperty(exports, "EnumStringMember", {
+ enumerable: true,
+ get: function () {
+ return _index.enumStringMember;
+ }
+});
+Object.defineProperty(exports, "EnumSymbolBody", {
+ enumerable: true,
+ get: function () {
+ return _index.enumSymbolBody;
+ }
+});
+Object.defineProperty(exports, "ExistsTypeAnnotation", {
+ enumerable: true,
+ get: function () {
+ return _index.existsTypeAnnotation;
+ }
+});
+Object.defineProperty(exports, "ExportAllDeclaration", {
+ enumerable: true,
+ get: function () {
+ return _index.exportAllDeclaration;
+ }
+});
+Object.defineProperty(exports, "ExportDefaultDeclaration", {
+ enumerable: true,
+ get: function () {
+ return _index.exportDefaultDeclaration;
+ }
+});
+Object.defineProperty(exports, "ExportDefaultSpecifier", {
+ enumerable: true,
+ get: function () {
+ return _index.exportDefaultSpecifier;
+ }
+});
+Object.defineProperty(exports, "ExportNamedDeclaration", {
+ enumerable: true,
+ get: function () {
+ return _index.exportNamedDeclaration;
+ }
+});
+Object.defineProperty(exports, "ExportNamespaceSpecifier", {
+ enumerable: true,
+ get: function () {
+ return _index.exportNamespaceSpecifier;
+ }
+});
+Object.defineProperty(exports, "ExportSpecifier", {
+ enumerable: true,
+ get: function () {
+ return _index.exportSpecifier;
+ }
+});
+Object.defineProperty(exports, "ExpressionStatement", {
+ enumerable: true,
+ get: function () {
+ return _index.expressionStatement;
+ }
+});
+Object.defineProperty(exports, "File", {
+ enumerable: true,
+ get: function () {
+ return _index.file;
+ }
+});
+Object.defineProperty(exports, "ForInStatement", {
+ enumerable: true,
+ get: function () {
+ return _index.forInStatement;
+ }
+});
+Object.defineProperty(exports, "ForOfStatement", {
+ enumerable: true,
+ get: function () {
+ return _index.forOfStatement;
+ }
+});
+Object.defineProperty(exports, "ForStatement", {
+ enumerable: true,
+ get: function () {
+ return _index.forStatement;
+ }
+});
+Object.defineProperty(exports, "FunctionDeclaration", {
+ enumerable: true,
+ get: function () {
+ return _index.functionDeclaration;
+ }
+});
+Object.defineProperty(exports, "FunctionExpression", {
+ enumerable: true,
+ get: function () {
+ return _index.functionExpression;
+ }
+});
+Object.defineProperty(exports, "FunctionTypeAnnotation", {
+ enumerable: true,
+ get: function () {
+ return _index.functionTypeAnnotation;
+ }
+});
+Object.defineProperty(exports, "FunctionTypeParam", {
+ enumerable: true,
+ get: function () {
+ return _index.functionTypeParam;
+ }
+});
+Object.defineProperty(exports, "GenericTypeAnnotation", {
+ enumerable: true,
+ get: function () {
+ return _index.genericTypeAnnotation;
+ }
+});
+Object.defineProperty(exports, "Identifier", {
+ enumerable: true,
+ get: function () {
+ return _index.identifier;
+ }
+});
+Object.defineProperty(exports, "IfStatement", {
+ enumerable: true,
+ get: function () {
+ return _index.ifStatement;
+ }
+});
+Object.defineProperty(exports, "Import", {
+ enumerable: true,
+ get: function () {
+ return _index.import;
+ }
+});
+Object.defineProperty(exports, "ImportAttribute", {
+ enumerable: true,
+ get: function () {
+ return _index.importAttribute;
+ }
+});
+Object.defineProperty(exports, "ImportDeclaration", {
+ enumerable: true,
+ get: function () {
+ return _index.importDeclaration;
+ }
+});
+Object.defineProperty(exports, "ImportDefaultSpecifier", {
+ enumerable: true,
+ get: function () {
+ return _index.importDefaultSpecifier;
+ }
+});
+Object.defineProperty(exports, "ImportNamespaceSpecifier", {
+ enumerable: true,
+ get: function () {
+ return _index.importNamespaceSpecifier;
+ }
+});
+Object.defineProperty(exports, "ImportSpecifier", {
+ enumerable: true,
+ get: function () {
+ return _index.importSpecifier;
+ }
+});
+Object.defineProperty(exports, "IndexedAccessType", {
+ enumerable: true,
+ get: function () {
+ return _index.indexedAccessType;
+ }
+});
+Object.defineProperty(exports, "InferredPredicate", {
+ enumerable: true,
+ get: function () {
+ return _index.inferredPredicate;
+ }
+});
+Object.defineProperty(exports, "InterfaceDeclaration", {
+ enumerable: true,
+ get: function () {
+ return _index.interfaceDeclaration;
+ }
+});
+Object.defineProperty(exports, "InterfaceExtends", {
+ enumerable: true,
+ get: function () {
+ return _index.interfaceExtends;
+ }
+});
+Object.defineProperty(exports, "InterfaceTypeAnnotation", {
+ enumerable: true,
+ get: function () {
+ return _index.interfaceTypeAnnotation;
+ }
+});
+Object.defineProperty(exports, "InterpreterDirective", {
+ enumerable: true,
+ get: function () {
+ return _index.interpreterDirective;
+ }
+});
+Object.defineProperty(exports, "IntersectionTypeAnnotation", {
+ enumerable: true,
+ get: function () {
+ return _index.intersectionTypeAnnotation;
+ }
+});
+Object.defineProperty(exports, "JSXAttribute", {
+ enumerable: true,
+ get: function () {
+ return _index.jsxAttribute;
+ }
+});
+Object.defineProperty(exports, "JSXClosingElement", {
+ enumerable: true,
+ get: function () {
+ return _index.jsxClosingElement;
+ }
+});
+Object.defineProperty(exports, "JSXClosingFragment", {
+ enumerable: true,
+ get: function () {
+ return _index.jsxClosingFragment;
+ }
+});
+Object.defineProperty(exports, "JSXElement", {
+ enumerable: true,
+ get: function () {
+ return _index.jsxElement;
+ }
+});
+Object.defineProperty(exports, "JSXEmptyExpression", {
+ enumerable: true,
+ get: function () {
+ return _index.jsxEmptyExpression;
+ }
+});
+Object.defineProperty(exports, "JSXExpressionContainer", {
+ enumerable: true,
+ get: function () {
+ return _index.jsxExpressionContainer;
+ }
+});
+Object.defineProperty(exports, "JSXFragment", {
+ enumerable: true,
+ get: function () {
+ return _index.jsxFragment;
+ }
+});
+Object.defineProperty(exports, "JSXIdentifier", {
+ enumerable: true,
+ get: function () {
+ return _index.jsxIdentifier;
+ }
+});
+Object.defineProperty(exports, "JSXMemberExpression", {
+ enumerable: true,
+ get: function () {
+ return _index.jsxMemberExpression;
+ }
+});
+Object.defineProperty(exports, "JSXNamespacedName", {
+ enumerable: true,
+ get: function () {
+ return _index.jsxNamespacedName;
+ }
+});
+Object.defineProperty(exports, "JSXOpeningElement", {
+ enumerable: true,
+ get: function () {
+ return _index.jsxOpeningElement;
+ }
+});
+Object.defineProperty(exports, "JSXOpeningFragment", {
+ enumerable: true,
+ get: function () {
+ return _index.jsxOpeningFragment;
+ }
+});
+Object.defineProperty(exports, "JSXSpreadAttribute", {
+ enumerable: true,
+ get: function () {
+ return _index.jsxSpreadAttribute;
+ }
+});
+Object.defineProperty(exports, "JSXSpreadChild", {
+ enumerable: true,
+ get: function () {
+ return _index.jsxSpreadChild;
+ }
+});
+Object.defineProperty(exports, "JSXText", {
+ enumerable: true,
+ get: function () {
+ return _index.jsxText;
+ }
+});
+Object.defineProperty(exports, "LabeledStatement", {
+ enumerable: true,
+ get: function () {
+ return _index.labeledStatement;
+ }
+});
+Object.defineProperty(exports, "LogicalExpression", {
+ enumerable: true,
+ get: function () {
+ return _index.logicalExpression;
+ }
+});
+Object.defineProperty(exports, "MemberExpression", {
+ enumerable: true,
+ get: function () {
+ return _index.memberExpression;
+ }
+});
+Object.defineProperty(exports, "MetaProperty", {
+ enumerable: true,
+ get: function () {
+ return _index.metaProperty;
+ }
+});
+Object.defineProperty(exports, "MixedTypeAnnotation", {
+ enumerable: true,
+ get: function () {
+ return _index.mixedTypeAnnotation;
+ }
+});
+Object.defineProperty(exports, "ModuleExpression", {
+ enumerable: true,
+ get: function () {
+ return _index.moduleExpression;
+ }
+});
+Object.defineProperty(exports, "NewExpression", {
+ enumerable: true,
+ get: function () {
+ return _index.newExpression;
+ }
+});
+Object.defineProperty(exports, "Noop", {
+ enumerable: true,
+ get: function () {
+ return _index.noop;
+ }
+});
+Object.defineProperty(exports, "NullLiteral", {
+ enumerable: true,
+ get: function () {
+ return _index.nullLiteral;
+ }
+});
+Object.defineProperty(exports, "NullLiteralTypeAnnotation", {
+ enumerable: true,
+ get: function () {
+ return _index.nullLiteralTypeAnnotation;
+ }
+});
+Object.defineProperty(exports, "NullableTypeAnnotation", {
+ enumerable: true,
+ get: function () {
+ return _index.nullableTypeAnnotation;
+ }
+});
+Object.defineProperty(exports, "NumberLiteral", {
+ enumerable: true,
+ get: function () {
+ return _index.numberLiteral;
+ }
+});
+Object.defineProperty(exports, "NumberLiteralTypeAnnotation", {
+ enumerable: true,
+ get: function () {
+ return _index.numberLiteralTypeAnnotation;
+ }
+});
+Object.defineProperty(exports, "NumberTypeAnnotation", {
+ enumerable: true,
+ get: function () {
+ return _index.numberTypeAnnotation;
+ }
+});
+Object.defineProperty(exports, "NumericLiteral", {
+ enumerable: true,
+ get: function () {
+ return _index.numericLiteral;
+ }
+});
+Object.defineProperty(exports, "ObjectExpression", {
+ enumerable: true,
+ get: function () {
+ return _index.objectExpression;
+ }
+});
+Object.defineProperty(exports, "ObjectMethod", {
+ enumerable: true,
+ get: function () {
+ return _index.objectMethod;
+ }
+});
+Object.defineProperty(exports, "ObjectPattern", {
+ enumerable: true,
+ get: function () {
+ return _index.objectPattern;
+ }
+});
+Object.defineProperty(exports, "ObjectProperty", {
+ enumerable: true,
+ get: function () {
+ return _index.objectProperty;
+ }
+});
+Object.defineProperty(exports, "ObjectTypeAnnotation", {
+ enumerable: true,
+ get: function () {
+ return _index.objectTypeAnnotation;
+ }
+});
+Object.defineProperty(exports, "ObjectTypeCallProperty", {
+ enumerable: true,
+ get: function () {
+ return _index.objectTypeCallProperty;
+ }
+});
+Object.defineProperty(exports, "ObjectTypeIndexer", {
+ enumerable: true,
+ get: function () {
+ return _index.objectTypeIndexer;
+ }
+});
+Object.defineProperty(exports, "ObjectTypeInternalSlot", {
+ enumerable: true,
+ get: function () {
+ return _index.objectTypeInternalSlot;
+ }
+});
+Object.defineProperty(exports, "ObjectTypeProperty", {
+ enumerable: true,
+ get: function () {
+ return _index.objectTypeProperty;
+ }
+});
+Object.defineProperty(exports, "ObjectTypeSpreadProperty", {
+ enumerable: true,
+ get: function () {
+ return _index.objectTypeSpreadProperty;
+ }
+});
+Object.defineProperty(exports, "OpaqueType", {
+ enumerable: true,
+ get: function () {
+ return _index.opaqueType;
+ }
+});
+Object.defineProperty(exports, "OptionalCallExpression", {
+ enumerable: true,
+ get: function () {
+ return _index.optionalCallExpression;
+ }
+});
+Object.defineProperty(exports, "OptionalIndexedAccessType", {
+ enumerable: true,
+ get: function () {
+ return _index.optionalIndexedAccessType;
+ }
+});
+Object.defineProperty(exports, "OptionalMemberExpression", {
+ enumerable: true,
+ get: function () {
+ return _index.optionalMemberExpression;
+ }
+});
+Object.defineProperty(exports, "ParenthesizedExpression", {
+ enumerable: true,
+ get: function () {
+ return _index.parenthesizedExpression;
+ }
+});
+Object.defineProperty(exports, "PipelineBareFunction", {
+ enumerable: true,
+ get: function () {
+ return _index.pipelineBareFunction;
+ }
+});
+Object.defineProperty(exports, "PipelinePrimaryTopicReference", {
+ enumerable: true,
+ get: function () {
+ return _index.pipelinePrimaryTopicReference;
+ }
+});
+Object.defineProperty(exports, "PipelineTopicExpression", {
+ enumerable: true,
+ get: function () {
+ return _index.pipelineTopicExpression;
+ }
+});
+Object.defineProperty(exports, "Placeholder", {
+ enumerable: true,
+ get: function () {
+ return _index.placeholder;
+ }
+});
+Object.defineProperty(exports, "PrivateName", {
+ enumerable: true,
+ get: function () {
+ return _index.privateName;
+ }
+});
+Object.defineProperty(exports, "Program", {
+ enumerable: true,
+ get: function () {
+ return _index.program;
+ }
+});
+Object.defineProperty(exports, "QualifiedTypeIdentifier", {
+ enumerable: true,
+ get: function () {
+ return _index.qualifiedTypeIdentifier;
+ }
+});
+Object.defineProperty(exports, "RecordExpression", {
+ enumerable: true,
+ get: function () {
+ return _index.recordExpression;
+ }
+});
+Object.defineProperty(exports, "RegExpLiteral", {
+ enumerable: true,
+ get: function () {
+ return _index.regExpLiteral;
+ }
+});
+Object.defineProperty(exports, "RegexLiteral", {
+ enumerable: true,
+ get: function () {
+ return _index.regexLiteral;
+ }
+});
+Object.defineProperty(exports, "RestElement", {
+ enumerable: true,
+ get: function () {
+ return _index.restElement;
+ }
+});
+Object.defineProperty(exports, "RestProperty", {
+ enumerable: true,
+ get: function () {
+ return _index.restProperty;
+ }
+});
+Object.defineProperty(exports, "ReturnStatement", {
+ enumerable: true,
+ get: function () {
+ return _index.returnStatement;
+ }
+});
+Object.defineProperty(exports, "SequenceExpression", {
+ enumerable: true,
+ get: function () {
+ return _index.sequenceExpression;
+ }
+});
+Object.defineProperty(exports, "SpreadElement", {
+ enumerable: true,
+ get: function () {
+ return _index.spreadElement;
+ }
+});
+Object.defineProperty(exports, "SpreadProperty", {
+ enumerable: true,
+ get: function () {
+ return _index.spreadProperty;
+ }
+});
+Object.defineProperty(exports, "StaticBlock", {
+ enumerable: true,
+ get: function () {
+ return _index.staticBlock;
+ }
+});
+Object.defineProperty(exports, "StringLiteral", {
+ enumerable: true,
+ get: function () {
+ return _index.stringLiteral;
+ }
+});
+Object.defineProperty(exports, "StringLiteralTypeAnnotation", {
+ enumerable: true,
+ get: function () {
+ return _index.stringLiteralTypeAnnotation;
+ }
+});
+Object.defineProperty(exports, "StringTypeAnnotation", {
+ enumerable: true,
+ get: function () {
+ return _index.stringTypeAnnotation;
+ }
+});
+Object.defineProperty(exports, "Super", {
+ enumerable: true,
+ get: function () {
+ return _index.super;
+ }
+});
+Object.defineProperty(exports, "SwitchCase", {
+ enumerable: true,
+ get: function () {
+ return _index.switchCase;
+ }
+});
+Object.defineProperty(exports, "SwitchStatement", {
+ enumerable: true,
+ get: function () {
+ return _index.switchStatement;
+ }
+});
+Object.defineProperty(exports, "SymbolTypeAnnotation", {
+ enumerable: true,
+ get: function () {
+ return _index.symbolTypeAnnotation;
+ }
+});
+Object.defineProperty(exports, "TSAnyKeyword", {
+ enumerable: true,
+ get: function () {
+ return _index.tsAnyKeyword;
+ }
+});
+Object.defineProperty(exports, "TSArrayType", {
+ enumerable: true,
+ get: function () {
+ return _index.tsArrayType;
+ }
+});
+Object.defineProperty(exports, "TSAsExpression", {
+ enumerable: true,
+ get: function () {
+ return _index.tsAsExpression;
+ }
+});
+Object.defineProperty(exports, "TSBigIntKeyword", {
+ enumerable: true,
+ get: function () {
+ return _index.tsBigIntKeyword;
+ }
+});
+Object.defineProperty(exports, "TSBooleanKeyword", {
+ enumerable: true,
+ get: function () {
+ return _index.tsBooleanKeyword;
+ }
+});
+Object.defineProperty(exports, "TSCallSignatureDeclaration", {
+ enumerable: true,
+ get: function () {
+ return _index.tsCallSignatureDeclaration;
+ }
+});
+Object.defineProperty(exports, "TSConditionalType", {
+ enumerable: true,
+ get: function () {
+ return _index.tsConditionalType;
+ }
+});
+Object.defineProperty(exports, "TSConstructSignatureDeclaration", {
+ enumerable: true,
+ get: function () {
+ return _index.tsConstructSignatureDeclaration;
+ }
+});
+Object.defineProperty(exports, "TSConstructorType", {
+ enumerable: true,
+ get: function () {
+ return _index.tsConstructorType;
+ }
+});
+Object.defineProperty(exports, "TSDeclareFunction", {
+ enumerable: true,
+ get: function () {
+ return _index.tsDeclareFunction;
+ }
+});
+Object.defineProperty(exports, "TSDeclareMethod", {
+ enumerable: true,
+ get: function () {
+ return _index.tsDeclareMethod;
+ }
+});
+Object.defineProperty(exports, "TSEnumDeclaration", {
+ enumerable: true,
+ get: function () {
+ return _index.tsEnumDeclaration;
+ }
+});
+Object.defineProperty(exports, "TSEnumMember", {
+ enumerable: true,
+ get: function () {
+ return _index.tsEnumMember;
+ }
+});
+Object.defineProperty(exports, "TSExportAssignment", {
+ enumerable: true,
+ get: function () {
+ return _index.tsExportAssignment;
+ }
+});
+Object.defineProperty(exports, "TSExpressionWithTypeArguments", {
+ enumerable: true,
+ get: function () {
+ return _index.tsExpressionWithTypeArguments;
+ }
+});
+Object.defineProperty(exports, "TSExternalModuleReference", {
+ enumerable: true,
+ get: function () {
+ return _index.tsExternalModuleReference;
+ }
+});
+Object.defineProperty(exports, "TSFunctionType", {
+ enumerable: true,
+ get: function () {
+ return _index.tsFunctionType;
+ }
+});
+Object.defineProperty(exports, "TSImportEqualsDeclaration", {
+ enumerable: true,
+ get: function () {
+ return _index.tsImportEqualsDeclaration;
+ }
+});
+Object.defineProperty(exports, "TSImportType", {
+ enumerable: true,
+ get: function () {
+ return _index.tsImportType;
+ }
+});
+Object.defineProperty(exports, "TSIndexSignature", {
+ enumerable: true,
+ get: function () {
+ return _index.tsIndexSignature;
+ }
+});
+Object.defineProperty(exports, "TSIndexedAccessType", {
+ enumerable: true,
+ get: function () {
+ return _index.tsIndexedAccessType;
+ }
+});
+Object.defineProperty(exports, "TSInferType", {
+ enumerable: true,
+ get: function () {
+ return _index.tsInferType;
+ }
+});
+Object.defineProperty(exports, "TSInterfaceBody", {
+ enumerable: true,
+ get: function () {
+ return _index.tsInterfaceBody;
+ }
+});
+Object.defineProperty(exports, "TSInterfaceDeclaration", {
+ enumerable: true,
+ get: function () {
+ return _index.tsInterfaceDeclaration;
+ }
+});
+Object.defineProperty(exports, "TSIntersectionType", {
+ enumerable: true,
+ get: function () {
+ return _index.tsIntersectionType;
+ }
+});
+Object.defineProperty(exports, "TSIntrinsicKeyword", {
+ enumerable: true,
+ get: function () {
+ return _index.tsIntrinsicKeyword;
+ }
+});
+Object.defineProperty(exports, "TSLiteralType", {
+ enumerable: true,
+ get: function () {
+ return _index.tsLiteralType;
+ }
+});
+Object.defineProperty(exports, "TSMappedType", {
+ enumerable: true,
+ get: function () {
+ return _index.tsMappedType;
+ }
+});
+Object.defineProperty(exports, "TSMethodSignature", {
+ enumerable: true,
+ get: function () {
+ return _index.tsMethodSignature;
+ }
+});
+Object.defineProperty(exports, "TSModuleBlock", {
+ enumerable: true,
+ get: function () {
+ return _index.tsModuleBlock;
+ }
+});
+Object.defineProperty(exports, "TSModuleDeclaration", {
+ enumerable: true,
+ get: function () {
+ return _index.tsModuleDeclaration;
+ }
+});
+Object.defineProperty(exports, "TSNamedTupleMember", {
+ enumerable: true,
+ get: function () {
+ return _index.tsNamedTupleMember;
+ }
+});
+Object.defineProperty(exports, "TSNamespaceExportDeclaration", {
+ enumerable: true,
+ get: function () {
+ return _index.tsNamespaceExportDeclaration;
+ }
+});
+Object.defineProperty(exports, "TSNeverKeyword", {
+ enumerable: true,
+ get: function () {
+ return _index.tsNeverKeyword;
+ }
+});
+Object.defineProperty(exports, "TSNonNullExpression", {
+ enumerable: true,
+ get: function () {
+ return _index.tsNonNullExpression;
+ }
+});
+Object.defineProperty(exports, "TSNullKeyword", {
+ enumerable: true,
+ get: function () {
+ return _index.tsNullKeyword;
+ }
+});
+Object.defineProperty(exports, "TSNumberKeyword", {
+ enumerable: true,
+ get: function () {
+ return _index.tsNumberKeyword;
+ }
+});
+Object.defineProperty(exports, "TSObjectKeyword", {
+ enumerable: true,
+ get: function () {
+ return _index.tsObjectKeyword;
+ }
+});
+Object.defineProperty(exports, "TSOptionalType", {
+ enumerable: true,
+ get: function () {
+ return _index.tsOptionalType;
+ }
+});
+Object.defineProperty(exports, "TSParameterProperty", {
+ enumerable: true,
+ get: function () {
+ return _index.tsParameterProperty;
+ }
+});
+Object.defineProperty(exports, "TSParenthesizedType", {
+ enumerable: true,
+ get: function () {
+ return _index.tsParenthesizedType;
+ }
+});
+Object.defineProperty(exports, "TSPropertySignature", {
+ enumerable: true,
+ get: function () {
+ return _index.tsPropertySignature;
+ }
+});
+Object.defineProperty(exports, "TSQualifiedName", {
+ enumerable: true,
+ get: function () {
+ return _index.tsQualifiedName;
+ }
+});
+Object.defineProperty(exports, "TSRestType", {
+ enumerable: true,
+ get: function () {
+ return _index.tsRestType;
+ }
+});
+Object.defineProperty(exports, "TSStringKeyword", {
+ enumerable: true,
+ get: function () {
+ return _index.tsStringKeyword;
+ }
+});
+Object.defineProperty(exports, "TSSymbolKeyword", {
+ enumerable: true,
+ get: function () {
+ return _index.tsSymbolKeyword;
+ }
+});
+Object.defineProperty(exports, "TSThisType", {
+ enumerable: true,
+ get: function () {
+ return _index.tsThisType;
+ }
+});
+Object.defineProperty(exports, "TSTupleType", {
+ enumerable: true,
+ get: function () {
+ return _index.tsTupleType;
+ }
+});
+Object.defineProperty(exports, "TSTypeAliasDeclaration", {
+ enumerable: true,
+ get: function () {
+ return _index.tsTypeAliasDeclaration;
+ }
+});
+Object.defineProperty(exports, "TSTypeAnnotation", {
+ enumerable: true,
+ get: function () {
+ return _index.tsTypeAnnotation;
+ }
+});
+Object.defineProperty(exports, "TSTypeAssertion", {
+ enumerable: true,
+ get: function () {
+ return _index.tsTypeAssertion;
+ }
+});
+Object.defineProperty(exports, "TSTypeLiteral", {
+ enumerable: true,
+ get: function () {
+ return _index.tsTypeLiteral;
+ }
+});
+Object.defineProperty(exports, "TSTypeOperator", {
+ enumerable: true,
+ get: function () {
+ return _index.tsTypeOperator;
+ }
+});
+Object.defineProperty(exports, "TSTypeParameter", {
+ enumerable: true,
+ get: function () {
+ return _index.tsTypeParameter;
+ }
+});
+Object.defineProperty(exports, "TSTypeParameterDeclaration", {
+ enumerable: true,
+ get: function () {
+ return _index.tsTypeParameterDeclaration;
+ }
+});
+Object.defineProperty(exports, "TSTypeParameterInstantiation", {
+ enumerable: true,
+ get: function () {
+ return _index.tsTypeParameterInstantiation;
+ }
+});
+Object.defineProperty(exports, "TSTypePredicate", {
+ enumerable: true,
+ get: function () {
+ return _index.tsTypePredicate;
+ }
+});
+Object.defineProperty(exports, "TSTypeQuery", {
+ enumerable: true,
+ get: function () {
+ return _index.tsTypeQuery;
+ }
+});
+Object.defineProperty(exports, "TSTypeReference", {
+ enumerable: true,
+ get: function () {
+ return _index.tsTypeReference;
+ }
+});
+Object.defineProperty(exports, "TSUndefinedKeyword", {
+ enumerable: true,
+ get: function () {
+ return _index.tsUndefinedKeyword;
+ }
+});
+Object.defineProperty(exports, "TSUnionType", {
+ enumerable: true,
+ get: function () {
+ return _index.tsUnionType;
+ }
+});
+Object.defineProperty(exports, "TSUnknownKeyword", {
+ enumerable: true,
+ get: function () {
+ return _index.tsUnknownKeyword;
+ }
+});
+Object.defineProperty(exports, "TSVoidKeyword", {
+ enumerable: true,
+ get: function () {
+ return _index.tsVoidKeyword;
+ }
+});
+Object.defineProperty(exports, "TaggedTemplateExpression", {
+ enumerable: true,
+ get: function () {
+ return _index.taggedTemplateExpression;
+ }
+});
+Object.defineProperty(exports, "TemplateElement", {
+ enumerable: true,
+ get: function () {
+ return _index.templateElement;
+ }
+});
+Object.defineProperty(exports, "TemplateLiteral", {
+ enumerable: true,
+ get: function () {
+ return _index.templateLiteral;
+ }
+});
+Object.defineProperty(exports, "ThisExpression", {
+ enumerable: true,
+ get: function () {
+ return _index.thisExpression;
+ }
+});
+Object.defineProperty(exports, "ThisTypeAnnotation", {
+ enumerable: true,
+ get: function () {
+ return _index.thisTypeAnnotation;
+ }
+});
+Object.defineProperty(exports, "ThrowStatement", {
+ enumerable: true,
+ get: function () {
+ return _index.throwStatement;
+ }
+});
+Object.defineProperty(exports, "TopicReference", {
+ enumerable: true,
+ get: function () {
+ return _index.topicReference;
+ }
+});
+Object.defineProperty(exports, "TryStatement", {
+ enumerable: true,
+ get: function () {
+ return _index.tryStatement;
+ }
+});
+Object.defineProperty(exports, "TupleExpression", {
+ enumerable: true,
+ get: function () {
+ return _index.tupleExpression;
+ }
+});
+Object.defineProperty(exports, "TupleTypeAnnotation", {
+ enumerable: true,
+ get: function () {
+ return _index.tupleTypeAnnotation;
+ }
+});
+Object.defineProperty(exports, "TypeAlias", {
+ enumerable: true,
+ get: function () {
+ return _index.typeAlias;
+ }
+});
+Object.defineProperty(exports, "TypeAnnotation", {
+ enumerable: true,
+ get: function () {
+ return _index.typeAnnotation;
+ }
+});
+Object.defineProperty(exports, "TypeCastExpression", {
+ enumerable: true,
+ get: function () {
+ return _index.typeCastExpression;
+ }
+});
+Object.defineProperty(exports, "TypeParameter", {
+ enumerable: true,
+ get: function () {
+ return _index.typeParameter;
+ }
+});
+Object.defineProperty(exports, "TypeParameterDeclaration", {
+ enumerable: true,
+ get: function () {
+ return _index.typeParameterDeclaration;
+ }
+});
+Object.defineProperty(exports, "TypeParameterInstantiation", {
+ enumerable: true,
+ get: function () {
+ return _index.typeParameterInstantiation;
+ }
+});
+Object.defineProperty(exports, "TypeofTypeAnnotation", {
+ enumerable: true,
+ get: function () {
+ return _index.typeofTypeAnnotation;
+ }
+});
+Object.defineProperty(exports, "UnaryExpression", {
+ enumerable: true,
+ get: function () {
+ return _index.unaryExpression;
+ }
+});
+Object.defineProperty(exports, "UnionTypeAnnotation", {
+ enumerable: true,
+ get: function () {
+ return _index.unionTypeAnnotation;
+ }
+});
+Object.defineProperty(exports, "UpdateExpression", {
+ enumerable: true,
+ get: function () {
+ return _index.updateExpression;
+ }
+});
+Object.defineProperty(exports, "V8IntrinsicIdentifier", {
+ enumerable: true,
+ get: function () {
+ return _index.v8IntrinsicIdentifier;
+ }
+});
+Object.defineProperty(exports, "VariableDeclaration", {
+ enumerable: true,
+ get: function () {
+ return _index.variableDeclaration;
+ }
+});
+Object.defineProperty(exports, "VariableDeclarator", {
+ enumerable: true,
+ get: function () {
+ return _index.variableDeclarator;
+ }
+});
+Object.defineProperty(exports, "Variance", {
+ enumerable: true,
+ get: function () {
+ return _index.variance;
+ }
+});
+Object.defineProperty(exports, "VoidTypeAnnotation", {
+ enumerable: true,
+ get: function () {
+ return _index.voidTypeAnnotation;
+ }
+});
+Object.defineProperty(exports, "WhileStatement", {
+ enumerable: true,
+ get: function () {
+ return _index.whileStatement;
+ }
+});
+Object.defineProperty(exports, "WithStatement", {
+ enumerable: true,
+ get: function () {
+ return _index.withStatement;
+ }
+});
+Object.defineProperty(exports, "YieldExpression", {
+ enumerable: true,
+ get: function () {
+ return _index.yieldExpression;
+ }
+});
+
+var _index = require("./index");
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/builders/react/buildChildren.js b/node_modules/@babel/types/lib/builders/react/buildChildren.js
new file mode 100644
index 000000000..20a194b6b
--- /dev/null
+++ b/node_modules/@babel/types/lib/builders/react/buildChildren.js
@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = buildChildren;
+
+var _generated = require("../../validators/generated");
+
+var _cleanJSXElementLiteralChild = require("../../utils/react/cleanJSXElementLiteralChild");
+
+function buildChildren(node) {
+ const elements = [];
+
+ for (let i = 0; i < node.children.length; i++) {
+ let child = node.children[i];
+
+ if ((0, _generated.isJSXText)(child)) {
+ (0, _cleanJSXElementLiteralChild.default)(child, elements);
+ continue;
+ }
+
+ if ((0, _generated.isJSXExpressionContainer)(child)) child = child.expression;
+ if ((0, _generated.isJSXEmptyExpression)(child)) continue;
+ elements.push(child);
+ }
+
+ return elements;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/builders/typescript/createTSUnionType.js b/node_modules/@babel/types/lib/builders/typescript/createTSUnionType.js
new file mode 100644
index 000000000..9b53be29d
--- /dev/null
+++ b/node_modules/@babel/types/lib/builders/typescript/createTSUnionType.js
@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = createTSUnionType;
+
+var _generated = require("../generated");
+
+var _removeTypeDuplicates = require("../../modifications/typescript/removeTypeDuplicates");
+
+function createTSUnionType(typeAnnotations) {
+ const types = typeAnnotations.map(type => type.typeAnnotation);
+ const flattened = (0, _removeTypeDuplicates.default)(types);
+
+ if (flattened.length === 1) {
+ return flattened[0];
+ } else {
+ return (0, _generated.tsUnionType)(flattened);
+ }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/clone/clone.js b/node_modules/@babel/types/lib/clone/clone.js
new file mode 100644
index 000000000..e262c632d
--- /dev/null
+++ b/node_modules/@babel/types/lib/clone/clone.js
@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = clone;
+
+var _cloneNode = require("./cloneNode");
+
+function clone(node) {
+ return (0, _cloneNode.default)(node, false);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/clone/cloneDeep.js b/node_modules/@babel/types/lib/clone/cloneDeep.js
new file mode 100644
index 000000000..9067e7b73
--- /dev/null
+++ b/node_modules/@babel/types/lib/clone/cloneDeep.js
@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = cloneDeep;
+
+var _cloneNode = require("./cloneNode");
+
+function cloneDeep(node) {
+ return (0, _cloneNode.default)(node);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/clone/cloneDeepWithoutLoc.js b/node_modules/@babel/types/lib/clone/cloneDeepWithoutLoc.js
new file mode 100644
index 000000000..a8c53dd4b
--- /dev/null
+++ b/node_modules/@babel/types/lib/clone/cloneDeepWithoutLoc.js
@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = cloneDeepWithoutLoc;
+
+var _cloneNode = require("./cloneNode");
+
+function cloneDeepWithoutLoc(node) {
+ return (0, _cloneNode.default)(node, true, true);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/clone/cloneNode.js b/node_modules/@babel/types/lib/clone/cloneNode.js
new file mode 100644
index 000000000..5980f2d1b
--- /dev/null
+++ b/node_modules/@babel/types/lib/clone/cloneNode.js
@@ -0,0 +1,114 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = cloneNode;
+
+var _definitions = require("../definitions");
+
+var _generated = require("../validators/generated");
+
+const has = Function.call.bind(Object.prototype.hasOwnProperty);
+
+function cloneIfNode(obj, deep, withoutLoc) {
+ if (obj && typeof obj.type === "string") {
+ return cloneNode(obj, deep, withoutLoc);
+ }
+
+ return obj;
+}
+
+function cloneIfNodeOrArray(obj, deep, withoutLoc) {
+ if (Array.isArray(obj)) {
+ return obj.map(node => cloneIfNode(node, deep, withoutLoc));
+ }
+
+ return cloneIfNode(obj, deep, withoutLoc);
+}
+
+function cloneNode(node, deep = true, withoutLoc = false) {
+ if (!node) return node;
+ const {
+ type
+ } = node;
+ const newNode = {
+ type: node.type
+ };
+
+ if ((0, _generated.isIdentifier)(node)) {
+ newNode.name = node.name;
+
+ if (has(node, "optional") && typeof node.optional === "boolean") {
+ newNode.optional = node.optional;
+ }
+
+ if (has(node, "typeAnnotation")) {
+ newNode.typeAnnotation = deep ? cloneIfNodeOrArray(node.typeAnnotation, true, withoutLoc) : node.typeAnnotation;
+ }
+ } else if (!has(_definitions.NODE_FIELDS, type)) {
+ throw new Error(`Unknown node type: "${type}"`);
+ } else {
+ for (const field of Object.keys(_definitions.NODE_FIELDS[type])) {
+ if (has(node, field)) {
+ if (deep) {
+ newNode[field] = (0, _generated.isFile)(node) && field === "comments" ? maybeCloneComments(node.comments, deep, withoutLoc) : cloneIfNodeOrArray(node[field], true, withoutLoc);
+ } else {
+ newNode[field] = node[field];
+ }
+ }
+ }
+ }
+
+ if (has(node, "loc")) {
+ if (withoutLoc) {
+ newNode.loc = null;
+ } else {
+ newNode.loc = node.loc;
+ }
+ }
+
+ if (has(node, "leadingComments")) {
+ newNode.leadingComments = maybeCloneComments(node.leadingComments, deep, withoutLoc);
+ }
+
+ if (has(node, "innerComments")) {
+ newNode.innerComments = maybeCloneComments(node.innerComments, deep, withoutLoc);
+ }
+
+ if (has(node, "trailingComments")) {
+ newNode.trailingComments = maybeCloneComments(node.trailingComments, deep, withoutLoc);
+ }
+
+ if (has(node, "extra")) {
+ newNode.extra = Object.assign({}, node.extra);
+ }
+
+ return newNode;
+}
+
+function maybeCloneComments(comments, deep, withoutLoc) {
+ if (!comments || !deep) {
+ return comments;
+ }
+
+ return comments.map(({
+ type,
+ value,
+ loc
+ }) => {
+ if (withoutLoc) {
+ return {
+ type,
+ value,
+ loc: null
+ };
+ }
+
+ return {
+ type,
+ value,
+ loc
+ };
+ });
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/clone/cloneWithoutLoc.js b/node_modules/@babel/types/lib/clone/cloneWithoutLoc.js
new file mode 100644
index 000000000..d0420b1c0
--- /dev/null
+++ b/node_modules/@babel/types/lib/clone/cloneWithoutLoc.js
@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = cloneWithoutLoc;
+
+var _cloneNode = require("./cloneNode");
+
+function cloneWithoutLoc(node) {
+ return (0, _cloneNode.default)(node, false, true);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/comments/addComment.js b/node_modules/@babel/types/lib/comments/addComment.js
new file mode 100644
index 000000000..de19ab74e
--- /dev/null
+++ b/node_modules/@babel/types/lib/comments/addComment.js
@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = addComment;
+
+var _addComments = require("./addComments");
+
+function addComment(node, type, content, line) {
+ return (0, _addComments.default)(node, type, [{
+ type: line ? "CommentLine" : "CommentBlock",
+ value: content
+ }]);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/comments/addComments.js b/node_modules/@babel/types/lib/comments/addComments.js
new file mode 100644
index 000000000..26c456fc3
--- /dev/null
+++ b/node_modules/@babel/types/lib/comments/addComments.js
@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = addComments;
+
+function addComments(node, type, comments) {
+ if (!comments || !node) return node;
+ const key = `${type}Comments`;
+
+ if (node[key]) {
+ if (type === "leading") {
+ node[key] = comments.concat(node[key]);
+ } else {
+ node[key].push(...comments);
+ }
+ } else {
+ node[key] = comments;
+ }
+
+ return node;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/comments/inheritInnerComments.js b/node_modules/@babel/types/lib/comments/inheritInnerComments.js
new file mode 100644
index 000000000..4b5dc9cac
--- /dev/null
+++ b/node_modules/@babel/types/lib/comments/inheritInnerComments.js
@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = inheritInnerComments;
+
+var _inherit = require("../utils/inherit");
+
+function inheritInnerComments(child, parent) {
+ (0, _inherit.default)("innerComments", child, parent);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/comments/inheritLeadingComments.js b/node_modules/@babel/types/lib/comments/inheritLeadingComments.js
new file mode 100644
index 000000000..6aa2b2502
--- /dev/null
+++ b/node_modules/@babel/types/lib/comments/inheritLeadingComments.js
@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = inheritLeadingComments;
+
+var _inherit = require("../utils/inherit");
+
+function inheritLeadingComments(child, parent) {
+ (0, _inherit.default)("leadingComments", child, parent);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/comments/inheritTrailingComments.js b/node_modules/@babel/types/lib/comments/inheritTrailingComments.js
new file mode 100644
index 000000000..934ef0b9c
--- /dev/null
+++ b/node_modules/@babel/types/lib/comments/inheritTrailingComments.js
@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = inheritTrailingComments;
+
+var _inherit = require("../utils/inherit");
+
+function inheritTrailingComments(child, parent) {
+ (0, _inherit.default)("trailingComments", child, parent);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/comments/inheritsComments.js b/node_modules/@babel/types/lib/comments/inheritsComments.js
new file mode 100644
index 000000000..49476cffd
--- /dev/null
+++ b/node_modules/@babel/types/lib/comments/inheritsComments.js
@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = inheritsComments;
+
+var _inheritTrailingComments = require("./inheritTrailingComments");
+
+var _inheritLeadingComments = require("./inheritLeadingComments");
+
+var _inheritInnerComments = require("./inheritInnerComments");
+
+function inheritsComments(child, parent) {
+ (0, _inheritTrailingComments.default)(child, parent);
+ (0, _inheritLeadingComments.default)(child, parent);
+ (0, _inheritInnerComments.default)(child, parent);
+ return child;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/comments/removeComments.js b/node_modules/@babel/types/lib/comments/removeComments.js
new file mode 100644
index 000000000..fe34f1a89
--- /dev/null
+++ b/node_modules/@babel/types/lib/comments/removeComments.js
@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = removeComments;
+
+var _constants = require("../constants");
+
+function removeComments(node) {
+ _constants.COMMENT_KEYS.forEach(key => {
+ node[key] = null;
+ });
+
+ return node;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/constants/generated/index.js b/node_modules/@babel/types/lib/constants/generated/index.js
new file mode 100644
index 000000000..1e109e6a4
--- /dev/null
+++ b/node_modules/@babel/types/lib/constants/generated/index.js
@@ -0,0 +1,107 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.WHILE_TYPES = exports.USERWHITESPACABLE_TYPES = exports.UNARYLIKE_TYPES = exports.TYPESCRIPT_TYPES = exports.TSTYPE_TYPES = exports.TSTYPEELEMENT_TYPES = exports.TSENTITYNAME_TYPES = exports.TSBASETYPE_TYPES = exports.TERMINATORLESS_TYPES = exports.STATEMENT_TYPES = exports.STANDARDIZED_TYPES = exports.SCOPABLE_TYPES = exports.PUREISH_TYPES = exports.PROPERTY_TYPES = exports.PRIVATE_TYPES = exports.PATTERN_TYPES = exports.PATTERNLIKE_TYPES = exports.OBJECTMEMBER_TYPES = exports.MODULESPECIFIER_TYPES = exports.MODULEDECLARATION_TYPES = exports.MISCELLANEOUS_TYPES = exports.METHOD_TYPES = exports.LVAL_TYPES = exports.LOOP_TYPES = exports.LITERAL_TYPES = exports.JSX_TYPES = exports.IMMUTABLE_TYPES = exports.FUNCTION_TYPES = exports.FUNCTIONPARENT_TYPES = exports.FOR_TYPES = exports.FORXSTATEMENT_TYPES = exports.FLOW_TYPES = exports.FLOWTYPE_TYPES = exports.FLOWPREDICATE_TYPES = exports.FLOWDECLARATION_TYPES = exports.FLOWBASEANNOTATION_TYPES = exports.EXPRESSION_TYPES = exports.EXPRESSIONWRAPPER_TYPES = exports.EXPORTDECLARATION_TYPES = exports.ENUMMEMBER_TYPES = exports.ENUMBODY_TYPES = exports.DECLARATION_TYPES = exports.CONDITIONAL_TYPES = exports.COMPLETIONSTATEMENT_TYPES = exports.CLASS_TYPES = exports.BLOCK_TYPES = exports.BLOCKPARENT_TYPES = exports.BINARY_TYPES = exports.ACCESSOR_TYPES = void 0;
+
+var _definitions = require("../../definitions");
+
+const STANDARDIZED_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Standardized"];
+exports.STANDARDIZED_TYPES = STANDARDIZED_TYPES;
+const EXPRESSION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Expression"];
+exports.EXPRESSION_TYPES = EXPRESSION_TYPES;
+const BINARY_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Binary"];
+exports.BINARY_TYPES = BINARY_TYPES;
+const SCOPABLE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Scopable"];
+exports.SCOPABLE_TYPES = SCOPABLE_TYPES;
+const BLOCKPARENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["BlockParent"];
+exports.BLOCKPARENT_TYPES = BLOCKPARENT_TYPES;
+const BLOCK_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Block"];
+exports.BLOCK_TYPES = BLOCK_TYPES;
+const STATEMENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Statement"];
+exports.STATEMENT_TYPES = STATEMENT_TYPES;
+const TERMINATORLESS_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Terminatorless"];
+exports.TERMINATORLESS_TYPES = TERMINATORLESS_TYPES;
+const COMPLETIONSTATEMENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["CompletionStatement"];
+exports.COMPLETIONSTATEMENT_TYPES = COMPLETIONSTATEMENT_TYPES;
+const CONDITIONAL_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Conditional"];
+exports.CONDITIONAL_TYPES = CONDITIONAL_TYPES;
+const LOOP_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Loop"];
+exports.LOOP_TYPES = LOOP_TYPES;
+const WHILE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["While"];
+exports.WHILE_TYPES = WHILE_TYPES;
+const EXPRESSIONWRAPPER_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ExpressionWrapper"];
+exports.EXPRESSIONWRAPPER_TYPES = EXPRESSIONWRAPPER_TYPES;
+const FOR_TYPES = _definitions.FLIPPED_ALIAS_KEYS["For"];
+exports.FOR_TYPES = FOR_TYPES;
+const FORXSTATEMENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ForXStatement"];
+exports.FORXSTATEMENT_TYPES = FORXSTATEMENT_TYPES;
+const FUNCTION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Function"];
+exports.FUNCTION_TYPES = FUNCTION_TYPES;
+const FUNCTIONPARENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FunctionParent"];
+exports.FUNCTIONPARENT_TYPES = FUNCTIONPARENT_TYPES;
+const PUREISH_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Pureish"];
+exports.PUREISH_TYPES = PUREISH_TYPES;
+const DECLARATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Declaration"];
+exports.DECLARATION_TYPES = DECLARATION_TYPES;
+const PATTERNLIKE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["PatternLike"];
+exports.PATTERNLIKE_TYPES = PATTERNLIKE_TYPES;
+const LVAL_TYPES = _definitions.FLIPPED_ALIAS_KEYS["LVal"];
+exports.LVAL_TYPES = LVAL_TYPES;
+const TSENTITYNAME_TYPES = _definitions.FLIPPED_ALIAS_KEYS["TSEntityName"];
+exports.TSENTITYNAME_TYPES = TSENTITYNAME_TYPES;
+const LITERAL_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Literal"];
+exports.LITERAL_TYPES = LITERAL_TYPES;
+const IMMUTABLE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Immutable"];
+exports.IMMUTABLE_TYPES = IMMUTABLE_TYPES;
+const USERWHITESPACABLE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["UserWhitespacable"];
+exports.USERWHITESPACABLE_TYPES = USERWHITESPACABLE_TYPES;
+const METHOD_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Method"];
+exports.METHOD_TYPES = METHOD_TYPES;
+const OBJECTMEMBER_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ObjectMember"];
+exports.OBJECTMEMBER_TYPES = OBJECTMEMBER_TYPES;
+const PROPERTY_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Property"];
+exports.PROPERTY_TYPES = PROPERTY_TYPES;
+const UNARYLIKE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["UnaryLike"];
+exports.UNARYLIKE_TYPES = UNARYLIKE_TYPES;
+const PATTERN_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Pattern"];
+exports.PATTERN_TYPES = PATTERN_TYPES;
+const CLASS_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Class"];
+exports.CLASS_TYPES = CLASS_TYPES;
+const MODULEDECLARATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ModuleDeclaration"];
+exports.MODULEDECLARATION_TYPES = MODULEDECLARATION_TYPES;
+const EXPORTDECLARATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ExportDeclaration"];
+exports.EXPORTDECLARATION_TYPES = EXPORTDECLARATION_TYPES;
+const MODULESPECIFIER_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ModuleSpecifier"];
+exports.MODULESPECIFIER_TYPES = MODULESPECIFIER_TYPES;
+const ACCESSOR_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Accessor"];
+exports.ACCESSOR_TYPES = ACCESSOR_TYPES;
+const PRIVATE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Private"];
+exports.PRIVATE_TYPES = PRIVATE_TYPES;
+const FLOW_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Flow"];
+exports.FLOW_TYPES = FLOW_TYPES;
+const FLOWTYPE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FlowType"];
+exports.FLOWTYPE_TYPES = FLOWTYPE_TYPES;
+const FLOWBASEANNOTATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FlowBaseAnnotation"];
+exports.FLOWBASEANNOTATION_TYPES = FLOWBASEANNOTATION_TYPES;
+const FLOWDECLARATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FlowDeclaration"];
+exports.FLOWDECLARATION_TYPES = FLOWDECLARATION_TYPES;
+const FLOWPREDICATE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FlowPredicate"];
+exports.FLOWPREDICATE_TYPES = FLOWPREDICATE_TYPES;
+const ENUMBODY_TYPES = _definitions.FLIPPED_ALIAS_KEYS["EnumBody"];
+exports.ENUMBODY_TYPES = ENUMBODY_TYPES;
+const ENUMMEMBER_TYPES = _definitions.FLIPPED_ALIAS_KEYS["EnumMember"];
+exports.ENUMMEMBER_TYPES = ENUMMEMBER_TYPES;
+const JSX_TYPES = _definitions.FLIPPED_ALIAS_KEYS["JSX"];
+exports.JSX_TYPES = JSX_TYPES;
+const MISCELLANEOUS_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Miscellaneous"];
+exports.MISCELLANEOUS_TYPES = MISCELLANEOUS_TYPES;
+const TYPESCRIPT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["TypeScript"];
+exports.TYPESCRIPT_TYPES = TYPESCRIPT_TYPES;
+const TSTYPEELEMENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["TSTypeElement"];
+exports.TSTYPEELEMENT_TYPES = TSTYPEELEMENT_TYPES;
+const TSTYPE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["TSType"];
+exports.TSTYPE_TYPES = TSTYPE_TYPES;
+const TSBASETYPE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["TSBaseType"];
+exports.TSBASETYPE_TYPES = TSBASETYPE_TYPES;
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/constants/index.js b/node_modules/@babel/types/lib/constants/index.js
new file mode 100644
index 000000000..3caa43879
--- /dev/null
+++ b/node_modules/@babel/types/lib/constants/index.js
@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.UPDATE_OPERATORS = exports.UNARY_OPERATORS = exports.STRING_UNARY_OPERATORS = exports.STATEMENT_OR_BLOCK_KEYS = exports.NUMBER_UNARY_OPERATORS = exports.NUMBER_BINARY_OPERATORS = exports.NOT_LOCAL_BINDING = exports.LOGICAL_OPERATORS = exports.INHERIT_KEYS = exports.FOR_INIT_KEYS = exports.FLATTENABLE_KEYS = exports.EQUALITY_BINARY_OPERATORS = exports.COMPARISON_BINARY_OPERATORS = exports.COMMENT_KEYS = exports.BOOLEAN_UNARY_OPERATORS = exports.BOOLEAN_NUMBER_BINARY_OPERATORS = exports.BOOLEAN_BINARY_OPERATORS = exports.BLOCK_SCOPED_SYMBOL = exports.BINARY_OPERATORS = exports.ASSIGNMENT_OPERATORS = void 0;
+const STATEMENT_OR_BLOCK_KEYS = ["consequent", "body", "alternate"];
+exports.STATEMENT_OR_BLOCK_KEYS = STATEMENT_OR_BLOCK_KEYS;
+const FLATTENABLE_KEYS = ["body", "expressions"];
+exports.FLATTENABLE_KEYS = FLATTENABLE_KEYS;
+const FOR_INIT_KEYS = ["left", "init"];
+exports.FOR_INIT_KEYS = FOR_INIT_KEYS;
+const COMMENT_KEYS = ["leadingComments", "trailingComments", "innerComments"];
+exports.COMMENT_KEYS = COMMENT_KEYS;
+const LOGICAL_OPERATORS = ["||", "&&", "??"];
+exports.LOGICAL_OPERATORS = LOGICAL_OPERATORS;
+const UPDATE_OPERATORS = ["++", "--"];
+exports.UPDATE_OPERATORS = UPDATE_OPERATORS;
+const BOOLEAN_NUMBER_BINARY_OPERATORS = [">", "<", ">=", "<="];
+exports.BOOLEAN_NUMBER_BINARY_OPERATORS = BOOLEAN_NUMBER_BINARY_OPERATORS;
+const EQUALITY_BINARY_OPERATORS = ["==", "===", "!=", "!=="];
+exports.EQUALITY_BINARY_OPERATORS = EQUALITY_BINARY_OPERATORS;
+const COMPARISON_BINARY_OPERATORS = [...EQUALITY_BINARY_OPERATORS, "in", "instanceof"];
+exports.COMPARISON_BINARY_OPERATORS = COMPARISON_BINARY_OPERATORS;
+const BOOLEAN_BINARY_OPERATORS = [...COMPARISON_BINARY_OPERATORS, ...BOOLEAN_NUMBER_BINARY_OPERATORS];
+exports.BOOLEAN_BINARY_OPERATORS = BOOLEAN_BINARY_OPERATORS;
+const NUMBER_BINARY_OPERATORS = ["-", "/", "%", "*", "**", "&", "|", ">>", ">>>", "<<", "^"];
+exports.NUMBER_BINARY_OPERATORS = NUMBER_BINARY_OPERATORS;
+const BINARY_OPERATORS = ["+", ...NUMBER_BINARY_OPERATORS, ...BOOLEAN_BINARY_OPERATORS];
+exports.BINARY_OPERATORS = BINARY_OPERATORS;
+const ASSIGNMENT_OPERATORS = ["=", "+=", ...NUMBER_BINARY_OPERATORS.map(op => op + "="), ...LOGICAL_OPERATORS.map(op => op + "=")];
+exports.ASSIGNMENT_OPERATORS = ASSIGNMENT_OPERATORS;
+const BOOLEAN_UNARY_OPERATORS = ["delete", "!"];
+exports.BOOLEAN_UNARY_OPERATORS = BOOLEAN_UNARY_OPERATORS;
+const NUMBER_UNARY_OPERATORS = ["+", "-", "~"];
+exports.NUMBER_UNARY_OPERATORS = NUMBER_UNARY_OPERATORS;
+const STRING_UNARY_OPERATORS = ["typeof"];
+exports.STRING_UNARY_OPERATORS = STRING_UNARY_OPERATORS;
+const UNARY_OPERATORS = ["void", "throw", ...BOOLEAN_UNARY_OPERATORS, ...NUMBER_UNARY_OPERATORS, ...STRING_UNARY_OPERATORS];
+exports.UNARY_OPERATORS = UNARY_OPERATORS;
+const INHERIT_KEYS = {
+ optional: ["typeAnnotation", "typeParameters", "returnType"],
+ force: ["start", "loc", "end"]
+};
+exports.INHERIT_KEYS = INHERIT_KEYS;
+const BLOCK_SCOPED_SYMBOL = Symbol.for("var used to be block scoped");
+exports.BLOCK_SCOPED_SYMBOL = BLOCK_SCOPED_SYMBOL;
+const NOT_LOCAL_BINDING = Symbol.for("should not be considered a local binding");
+exports.NOT_LOCAL_BINDING = NOT_LOCAL_BINDING;
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/converters/Scope.js b/node_modules/@babel/types/lib/converters/Scope.js
new file mode 100644
index 000000000..e69de29bb
diff --git a/node_modules/@babel/types/lib/converters/ensureBlock.js b/node_modules/@babel/types/lib/converters/ensureBlock.js
new file mode 100644
index 000000000..56fdf1fdb
--- /dev/null
+++ b/node_modules/@babel/types/lib/converters/ensureBlock.js
@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = ensureBlock;
+
+var _toBlock = require("./toBlock");
+
+function ensureBlock(node, key = "body") {
+ return node[key] = (0, _toBlock.default)(node[key], node);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/converters/gatherSequenceExpressions.js b/node_modules/@babel/types/lib/converters/gatherSequenceExpressions.js
new file mode 100644
index 000000000..379e5ffe0
--- /dev/null
+++ b/node_modules/@babel/types/lib/converters/gatherSequenceExpressions.js
@@ -0,0 +1,75 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = gatherSequenceExpressions;
+
+var _getBindingIdentifiers = require("../retrievers/getBindingIdentifiers");
+
+var _generated = require("../validators/generated");
+
+var _generated2 = require("../builders/generated");
+
+var _cloneNode = require("../clone/cloneNode");
+
+function gatherSequenceExpressions(nodes, scope, declars) {
+ const exprs = [];
+ let ensureLastUndefined = true;
+
+ for (const node of nodes) {
+ if (!(0, _generated.isEmptyStatement)(node)) {
+ ensureLastUndefined = false;
+ }
+
+ if ((0, _generated.isExpression)(node)) {
+ exprs.push(node);
+ } else if ((0, _generated.isExpressionStatement)(node)) {
+ exprs.push(node.expression);
+ } else if ((0, _generated.isVariableDeclaration)(node)) {
+ if (node.kind !== "var") return;
+
+ for (const declar of node.declarations) {
+ const bindings = (0, _getBindingIdentifiers.default)(declar);
+
+ for (const key of Object.keys(bindings)) {
+ declars.push({
+ kind: node.kind,
+ id: (0, _cloneNode.default)(bindings[key])
+ });
+ }
+
+ if (declar.init) {
+ exprs.push((0, _generated2.assignmentExpression)("=", declar.id, declar.init));
+ }
+ }
+
+ ensureLastUndefined = true;
+ } else if ((0, _generated.isIfStatement)(node)) {
+ const consequent = node.consequent ? gatherSequenceExpressions([node.consequent], scope, declars) : scope.buildUndefinedNode();
+ const alternate = node.alternate ? gatherSequenceExpressions([node.alternate], scope, declars) : scope.buildUndefinedNode();
+ if (!consequent || !alternate) return;
+ exprs.push((0, _generated2.conditionalExpression)(node.test, consequent, alternate));
+ } else if ((0, _generated.isBlockStatement)(node)) {
+ const body = gatherSequenceExpressions(node.body, scope, declars);
+ if (!body) return;
+ exprs.push(body);
+ } else if ((0, _generated.isEmptyStatement)(node)) {
+ if (nodes.indexOf(node) === 0) {
+ ensureLastUndefined = true;
+ }
+ } else {
+ return;
+ }
+ }
+
+ if (ensureLastUndefined) {
+ exprs.push(scope.buildUndefinedNode());
+ }
+
+ if (exprs.length === 1) {
+ return exprs[0];
+ } else {
+ return (0, _generated2.sequenceExpression)(exprs);
+ }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/converters/toBindingIdentifierName.js b/node_modules/@babel/types/lib/converters/toBindingIdentifierName.js
new file mode 100644
index 000000000..6bbce6e55
--- /dev/null
+++ b/node_modules/@babel/types/lib/converters/toBindingIdentifierName.js
@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = toBindingIdentifierName;
+
+var _toIdentifier = require("./toIdentifier");
+
+function toBindingIdentifierName(name) {
+ name = (0, _toIdentifier.default)(name);
+ if (name === "eval" || name === "arguments") name = "_" + name;
+ return name;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/converters/toBlock.js b/node_modules/@babel/types/lib/converters/toBlock.js
new file mode 100644
index 000000000..19886833f
--- /dev/null
+++ b/node_modules/@babel/types/lib/converters/toBlock.js
@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = toBlock;
+
+var _generated = require("../validators/generated");
+
+var _generated2 = require("../builders/generated");
+
+function toBlock(node, parent) {
+ if ((0, _generated.isBlockStatement)(node)) {
+ return node;
+ }
+
+ let blockNodes = [];
+
+ if ((0, _generated.isEmptyStatement)(node)) {
+ blockNodes = [];
+ } else {
+ if (!(0, _generated.isStatement)(node)) {
+ if ((0, _generated.isFunction)(parent)) {
+ node = (0, _generated2.returnStatement)(node);
+ } else {
+ node = (0, _generated2.expressionStatement)(node);
+ }
+ }
+
+ blockNodes = [node];
+ }
+
+ return (0, _generated2.blockStatement)(blockNodes);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/converters/toComputedKey.js b/node_modules/@babel/types/lib/converters/toComputedKey.js
new file mode 100644
index 000000000..31e6770f6
--- /dev/null
+++ b/node_modules/@babel/types/lib/converters/toComputedKey.js
@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = toComputedKey;
+
+var _generated = require("../validators/generated");
+
+var _generated2 = require("../builders/generated");
+
+function toComputedKey(node, key = node.key || node.property) {
+ if (!node.computed && (0, _generated.isIdentifier)(key)) key = (0, _generated2.stringLiteral)(key.name);
+ return key;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/converters/toExpression.js b/node_modules/@babel/types/lib/converters/toExpression.js
new file mode 100644
index 000000000..2d944f0e9
--- /dev/null
+++ b/node_modules/@babel/types/lib/converters/toExpression.js
@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = void 0;
+
+var _generated = require("../validators/generated");
+
+var _default = toExpression;
+exports.default = _default;
+
+function toExpression(node) {
+ if ((0, _generated.isExpressionStatement)(node)) {
+ node = node.expression;
+ }
+
+ if ((0, _generated.isExpression)(node)) {
+ return node;
+ }
+
+ if ((0, _generated.isClass)(node)) {
+ node.type = "ClassExpression";
+ } else if ((0, _generated.isFunction)(node)) {
+ node.type = "FunctionExpression";
+ }
+
+ if (!(0, _generated.isExpression)(node)) {
+ throw new Error(`cannot turn ${node.type} to an expression`);
+ }
+
+ return node;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/converters/toIdentifier.js b/node_modules/@babel/types/lib/converters/toIdentifier.js
new file mode 100644
index 000000000..2fd4028d2
--- /dev/null
+++ b/node_modules/@babel/types/lib/converters/toIdentifier.js
@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = toIdentifier;
+
+var _isValidIdentifier = require("../validators/isValidIdentifier");
+
+var _helperValidatorIdentifier = require("@babel/helper-validator-identifier");
+
+function toIdentifier(input) {
+ input = input + "";
+ let name = "";
+
+ for (const c of input) {
+ name += (0, _helperValidatorIdentifier.isIdentifierChar)(c.codePointAt(0)) ? c : "-";
+ }
+
+ name = name.replace(/^[-0-9]+/, "");
+ name = name.replace(/[-\s]+(.)?/g, function (match, c) {
+ return c ? c.toUpperCase() : "";
+ });
+
+ if (!(0, _isValidIdentifier.default)(name)) {
+ name = `_${name}`;
+ }
+
+ return name || "_";
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/converters/toKeyAlias.js b/node_modules/@babel/types/lib/converters/toKeyAlias.js
new file mode 100644
index 000000000..49ef4b8ad
--- /dev/null
+++ b/node_modules/@babel/types/lib/converters/toKeyAlias.js
@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = toKeyAlias;
+
+var _generated = require("../validators/generated");
+
+var _cloneNode = require("../clone/cloneNode");
+
+var _removePropertiesDeep = require("../modifications/removePropertiesDeep");
+
+function toKeyAlias(node, key = node.key) {
+ let alias;
+
+ if (node.kind === "method") {
+ return toKeyAlias.increment() + "";
+ } else if ((0, _generated.isIdentifier)(key)) {
+ alias = key.name;
+ } else if ((0, _generated.isStringLiteral)(key)) {
+ alias = JSON.stringify(key.value);
+ } else {
+ alias = JSON.stringify((0, _removePropertiesDeep.default)((0, _cloneNode.default)(key)));
+ }
+
+ if (node.computed) {
+ alias = `[${alias}]`;
+ }
+
+ if (node.static) {
+ alias = `static:${alias}`;
+ }
+
+ return alias;
+}
+
+toKeyAlias.uid = 0;
+
+toKeyAlias.increment = function () {
+ if (toKeyAlias.uid >= Number.MAX_SAFE_INTEGER) {
+ return toKeyAlias.uid = 0;
+ } else {
+ return toKeyAlias.uid++;
+ }
+};
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/converters/toSequenceExpression.js b/node_modules/@babel/types/lib/converters/toSequenceExpression.js
new file mode 100644
index 000000000..c3d3133ec
--- /dev/null
+++ b/node_modules/@babel/types/lib/converters/toSequenceExpression.js
@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = toSequenceExpression;
+
+var _gatherSequenceExpressions = require("./gatherSequenceExpressions");
+
+function toSequenceExpression(nodes, scope) {
+ if (!(nodes != null && nodes.length)) return;
+ const declars = [];
+ const result = (0, _gatherSequenceExpressions.default)(nodes, scope, declars);
+ if (!result) return;
+
+ for (const declar of declars) {
+ scope.push(declar);
+ }
+
+ return result;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/converters/toStatement.js b/node_modules/@babel/types/lib/converters/toStatement.js
new file mode 100644
index 000000000..da020a61a
--- /dev/null
+++ b/node_modules/@babel/types/lib/converters/toStatement.js
@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = void 0;
+
+var _generated = require("../validators/generated");
+
+var _generated2 = require("../builders/generated");
+
+var _default = toStatement;
+exports.default = _default;
+
+function toStatement(node, ignore) {
+ if ((0, _generated.isStatement)(node)) {
+ return node;
+ }
+
+ let mustHaveId = false;
+ let newType;
+
+ if ((0, _generated.isClass)(node)) {
+ mustHaveId = true;
+ newType = "ClassDeclaration";
+ } else if ((0, _generated.isFunction)(node)) {
+ mustHaveId = true;
+ newType = "FunctionDeclaration";
+ } else if ((0, _generated.isAssignmentExpression)(node)) {
+ return (0, _generated2.expressionStatement)(node);
+ }
+
+ if (mustHaveId && !node.id) {
+ newType = false;
+ }
+
+ if (!newType) {
+ if (ignore) {
+ return false;
+ } else {
+ throw new Error(`cannot turn ${node.type} to a statement`);
+ }
+ }
+
+ node.type = newType;
+ return node;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/converters/valueToNode.js b/node_modules/@babel/types/lib/converters/valueToNode.js
new file mode 100644
index 000000000..b3e531b35
--- /dev/null
+++ b/node_modules/@babel/types/lib/converters/valueToNode.js
@@ -0,0 +1,99 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = void 0;
+
+var _isValidIdentifier = require("../validators/isValidIdentifier");
+
+var _generated = require("../builders/generated");
+
+var _default = valueToNode;
+exports.default = _default;
+const objectToString = Function.call.bind(Object.prototype.toString);
+
+function isRegExp(value) {
+ return objectToString(value) === "[object RegExp]";
+}
+
+function isPlainObject(value) {
+ if (typeof value !== "object" || value === null || Object.prototype.toString.call(value) !== "[object Object]") {
+ return false;
+ }
+
+ const proto = Object.getPrototypeOf(value);
+ return proto === null || Object.getPrototypeOf(proto) === null;
+}
+
+function valueToNode(value) {
+ if (value === undefined) {
+ return (0, _generated.identifier)("undefined");
+ }
+
+ if (value === true || value === false) {
+ return (0, _generated.booleanLiteral)(value);
+ }
+
+ if (value === null) {
+ return (0, _generated.nullLiteral)();
+ }
+
+ if (typeof value === "string") {
+ return (0, _generated.stringLiteral)(value);
+ }
+
+ if (typeof value === "number") {
+ let result;
+
+ if (Number.isFinite(value)) {
+ result = (0, _generated.numericLiteral)(Math.abs(value));
+ } else {
+ let numerator;
+
+ if (Number.isNaN(value)) {
+ numerator = (0, _generated.numericLiteral)(0);
+ } else {
+ numerator = (0, _generated.numericLiteral)(1);
+ }
+
+ result = (0, _generated.binaryExpression)("/", numerator, (0, _generated.numericLiteral)(0));
+ }
+
+ if (value < 0 || Object.is(value, -0)) {
+ result = (0, _generated.unaryExpression)("-", result);
+ }
+
+ return result;
+ }
+
+ if (isRegExp(value)) {
+ const pattern = value.source;
+ const flags = value.toString().match(/\/([a-z]+|)$/)[1];
+ return (0, _generated.regExpLiteral)(pattern, flags);
+ }
+
+ if (Array.isArray(value)) {
+ return (0, _generated.arrayExpression)(value.map(valueToNode));
+ }
+
+ if (isPlainObject(value)) {
+ const props = [];
+
+ for (const key of Object.keys(value)) {
+ let nodeKey;
+
+ if ((0, _isValidIdentifier.default)(key)) {
+ nodeKey = (0, _generated.identifier)(key);
+ } else {
+ nodeKey = (0, _generated.stringLiteral)(key);
+ }
+
+ props.push((0, _generated.objectProperty)(nodeKey, valueToNode(value[key])));
+ }
+
+ return (0, _generated.objectExpression)(props);
+ }
+
+ throw new Error("don't know how to turn this value into a node");
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/definitions/core.js b/node_modules/@babel/types/lib/definitions/core.js
new file mode 100644
index 000000000..1c4673392
--- /dev/null
+++ b/node_modules/@babel/types/lib/definitions/core.js
@@ -0,0 +1,1649 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.patternLikeCommon = exports.functionTypeAnnotationCommon = exports.functionDeclarationCommon = exports.functionCommon = exports.classMethodOrPropertyCommon = exports.classMethodOrDeclareMethodCommon = void 0;
+
+var _is = require("../validators/is");
+
+var _isValidIdentifier = require("../validators/isValidIdentifier");
+
+var _helperValidatorIdentifier = require("@babel/helper-validator-identifier");
+
+var _constants = require("../constants");
+
+var _utils = require("./utils");
+
+const defineType = (0, _utils.defineAliasedType)("Standardized");
+defineType("ArrayExpression", {
+ fields: {
+ elements: {
+ validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeOrValueType)("null", "Expression", "SpreadElement"))),
+ default: !process.env.BABEL_TYPES_8_BREAKING ? [] : undefined
+ }
+ },
+ visitor: ["elements"],
+ aliases: ["Expression"]
+});
+defineType("AssignmentExpression", {
+ fields: {
+ operator: {
+ validate: function () {
+ if (!process.env.BABEL_TYPES_8_BREAKING) {
+ return (0, _utils.assertValueType)("string");
+ }
+
+ const identifier = (0, _utils.assertOneOf)(..._constants.ASSIGNMENT_OPERATORS);
+ const pattern = (0, _utils.assertOneOf)("=");
+ return function (node, key, val) {
+ const validator = (0, _is.default)("Pattern", node.left) ? pattern : identifier;
+ validator(node, key, val);
+ };
+ }()
+ },
+ left: {
+ validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertNodeType)("LVal") : (0, _utils.assertNodeType)("Identifier", "MemberExpression", "ArrayPattern", "ObjectPattern")
+ },
+ right: {
+ validate: (0, _utils.assertNodeType)("Expression")
+ }
+ },
+ builder: ["operator", "left", "right"],
+ visitor: ["left", "right"],
+ aliases: ["Expression"]
+});
+defineType("BinaryExpression", {
+ builder: ["operator", "left", "right"],
+ fields: {
+ operator: {
+ validate: (0, _utils.assertOneOf)(..._constants.BINARY_OPERATORS)
+ },
+ left: {
+ validate: function () {
+ const expression = (0, _utils.assertNodeType)("Expression");
+ const inOp = (0, _utils.assertNodeType)("Expression", "PrivateName");
+
+ const validator = function (node, key, val) {
+ const validator = node.operator === "in" ? inOp : expression;
+ validator(node, key, val);
+ };
+
+ validator.oneOfNodeTypes = ["Expression", "PrivateName"];
+ return validator;
+ }()
+ },
+ right: {
+ validate: (0, _utils.assertNodeType)("Expression")
+ }
+ },
+ visitor: ["left", "right"],
+ aliases: ["Binary", "Expression"]
+});
+defineType("InterpreterDirective", {
+ builder: ["value"],
+ fields: {
+ value: {
+ validate: (0, _utils.assertValueType)("string")
+ }
+ }
+});
+defineType("Directive", {
+ visitor: ["value"],
+ fields: {
+ value: {
+ validate: (0, _utils.assertNodeType)("DirectiveLiteral")
+ }
+ }
+});
+defineType("DirectiveLiteral", {
+ builder: ["value"],
+ fields: {
+ value: {
+ validate: (0, _utils.assertValueType)("string")
+ }
+ }
+});
+defineType("BlockStatement", {
+ builder: ["body", "directives"],
+ visitor: ["directives", "body"],
+ fields: {
+ directives: {
+ validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Directive"))),
+ default: []
+ },
+ body: {
+ validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Statement")))
+ }
+ },
+ aliases: ["Scopable", "BlockParent", "Block", "Statement"]
+});
+defineType("BreakStatement", {
+ visitor: ["label"],
+ fields: {
+ label: {
+ validate: (0, _utils.assertNodeType)("Identifier"),
+ optional: true
+ }
+ },
+ aliases: ["Statement", "Terminatorless", "CompletionStatement"]
+});
+defineType("CallExpression", {
+ visitor: ["callee", "arguments", "typeParameters", "typeArguments"],
+ builder: ["callee", "arguments"],
+ aliases: ["Expression"],
+ fields: Object.assign({
+ callee: {
+ validate: (0, _utils.assertNodeType)("Expression", "V8IntrinsicIdentifier")
+ },
+ arguments: {
+ validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression", "SpreadElement", "JSXNamespacedName", "ArgumentPlaceholder")))
+ }
+ }, !process.env.BABEL_TYPES_8_BREAKING ? {
+ optional: {
+ validate: (0, _utils.assertOneOf)(true, false),
+ optional: true
+ }
+ } : {}, {
+ typeArguments: {
+ validate: (0, _utils.assertNodeType)("TypeParameterInstantiation"),
+ optional: true
+ },
+ typeParameters: {
+ validate: (0, _utils.assertNodeType)("TSTypeParameterInstantiation"),
+ optional: true
+ }
+ })
+});
+defineType("CatchClause", {
+ visitor: ["param", "body"],
+ fields: {
+ param: {
+ validate: (0, _utils.assertNodeType)("Identifier", "ArrayPattern", "ObjectPattern"),
+ optional: true
+ },
+ body: {
+ validate: (0, _utils.assertNodeType)("BlockStatement")
+ }
+ },
+ aliases: ["Scopable", "BlockParent"]
+});
+defineType("ConditionalExpression", {
+ visitor: ["test", "consequent", "alternate"],
+ fields: {
+ test: {
+ validate: (0, _utils.assertNodeType)("Expression")
+ },
+ consequent: {
+ validate: (0, _utils.assertNodeType)("Expression")
+ },
+ alternate: {
+ validate: (0, _utils.assertNodeType)("Expression")
+ }
+ },
+ aliases: ["Expression", "Conditional"]
+});
+defineType("ContinueStatement", {
+ visitor: ["label"],
+ fields: {
+ label: {
+ validate: (0, _utils.assertNodeType)("Identifier"),
+ optional: true
+ }
+ },
+ aliases: ["Statement", "Terminatorless", "CompletionStatement"]
+});
+defineType("DebuggerStatement", {
+ aliases: ["Statement"]
+});
+defineType("DoWhileStatement", {
+ visitor: ["test", "body"],
+ fields: {
+ test: {
+ validate: (0, _utils.assertNodeType)("Expression")
+ },
+ body: {
+ validate: (0, _utils.assertNodeType)("Statement")
+ }
+ },
+ aliases: ["Statement", "BlockParent", "Loop", "While", "Scopable"]
+});
+defineType("EmptyStatement", {
+ aliases: ["Statement"]
+});
+defineType("ExpressionStatement", {
+ visitor: ["expression"],
+ fields: {
+ expression: {
+ validate: (0, _utils.assertNodeType)("Expression")
+ }
+ },
+ aliases: ["Statement", "ExpressionWrapper"]
+});
+defineType("File", {
+ builder: ["program", "comments", "tokens"],
+ visitor: ["program"],
+ fields: {
+ program: {
+ validate: (0, _utils.assertNodeType)("Program")
+ },
+ comments: {
+ validate: !process.env.BABEL_TYPES_8_BREAKING ? Object.assign(() => {}, {
+ each: {
+ oneOfNodeTypes: ["CommentBlock", "CommentLine"]
+ }
+ }) : (0, _utils.assertEach)((0, _utils.assertNodeType)("CommentBlock", "CommentLine")),
+ optional: true
+ },
+ tokens: {
+ validate: (0, _utils.assertEach)(Object.assign(() => {}, {
+ type: "any"
+ })),
+ optional: true
+ }
+ }
+});
+defineType("ForInStatement", {
+ visitor: ["left", "right", "body"],
+ aliases: ["Scopable", "Statement", "For", "BlockParent", "Loop", "ForXStatement"],
+ fields: {
+ left: {
+ validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertNodeType)("VariableDeclaration", "LVal") : (0, _utils.assertNodeType)("VariableDeclaration", "Identifier", "MemberExpression", "ArrayPattern", "ObjectPattern")
+ },
+ right: {
+ validate: (0, _utils.assertNodeType)("Expression")
+ },
+ body: {
+ validate: (0, _utils.assertNodeType)("Statement")
+ }
+ }
+});
+defineType("ForStatement", {
+ visitor: ["init", "test", "update", "body"],
+ aliases: ["Scopable", "Statement", "For", "BlockParent", "Loop"],
+ fields: {
+ init: {
+ validate: (0, _utils.assertNodeType)("VariableDeclaration", "Expression"),
+ optional: true
+ },
+ test: {
+ validate: (0, _utils.assertNodeType)("Expression"),
+ optional: true
+ },
+ update: {
+ validate: (0, _utils.assertNodeType)("Expression"),
+ optional: true
+ },
+ body: {
+ validate: (0, _utils.assertNodeType)("Statement")
+ }
+ }
+});
+const functionCommon = {
+ params: {
+ validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Identifier", "Pattern", "RestElement")))
+ },
+ generator: {
+ default: false
+ },
+ async: {
+ default: false
+ }
+};
+exports.functionCommon = functionCommon;
+const functionTypeAnnotationCommon = {
+ returnType: {
+ validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"),
+ optional: true
+ },
+ typeParameters: {
+ validate: (0, _utils.assertNodeType)("TypeParameterDeclaration", "TSTypeParameterDeclaration", "Noop"),
+ optional: true
+ }
+};
+exports.functionTypeAnnotationCommon = functionTypeAnnotationCommon;
+const functionDeclarationCommon = Object.assign({}, functionCommon, {
+ declare: {
+ validate: (0, _utils.assertValueType)("boolean"),
+ optional: true
+ },
+ id: {
+ validate: (0, _utils.assertNodeType)("Identifier"),
+ optional: true
+ }
+});
+exports.functionDeclarationCommon = functionDeclarationCommon;
+defineType("FunctionDeclaration", {
+ builder: ["id", "params", "body", "generator", "async"],
+ visitor: ["id", "params", "body", "returnType", "typeParameters"],
+ fields: Object.assign({}, functionDeclarationCommon, functionTypeAnnotationCommon, {
+ body: {
+ validate: (0, _utils.assertNodeType)("BlockStatement")
+ }
+ }),
+ aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Statement", "Pureish", "Declaration"],
+ validate: function () {
+ if (!process.env.BABEL_TYPES_8_BREAKING) return () => {};
+ const identifier = (0, _utils.assertNodeType)("Identifier");
+ return function (parent, key, node) {
+ if (!(0, _is.default)("ExportDefaultDeclaration", parent)) {
+ identifier(node, "id", node.id);
+ }
+ };
+ }()
+});
+defineType("FunctionExpression", {
+ inherits: "FunctionDeclaration",
+ aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Expression", "Pureish"],
+ fields: Object.assign({}, functionCommon, functionTypeAnnotationCommon, {
+ id: {
+ validate: (0, _utils.assertNodeType)("Identifier"),
+ optional: true
+ },
+ body: {
+ validate: (0, _utils.assertNodeType)("BlockStatement")
+ }
+ })
+});
+const patternLikeCommon = {
+ typeAnnotation: {
+ validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"),
+ optional: true
+ },
+ decorators: {
+ validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator")))
+ }
+};
+exports.patternLikeCommon = patternLikeCommon;
+defineType("Identifier", {
+ builder: ["name"],
+ visitor: ["typeAnnotation", "decorators"],
+ aliases: ["Expression", "PatternLike", "LVal", "TSEntityName"],
+ fields: Object.assign({}, patternLikeCommon, {
+ name: {
+ validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), Object.assign(function (node, key, val) {
+ if (!process.env.BABEL_TYPES_8_BREAKING) return;
+
+ if (!(0, _isValidIdentifier.default)(val, false)) {
+ throw new TypeError(`"${val}" is not a valid identifier name`);
+ }
+ }, {
+ type: "string"
+ }))
+ },
+ optional: {
+ validate: (0, _utils.assertValueType)("boolean"),
+ optional: true
+ }
+ }),
+
+ validate(parent, key, node) {
+ if (!process.env.BABEL_TYPES_8_BREAKING) return;
+ const match = /\.(\w+)$/.exec(key);
+ if (!match) return;
+ const [, parentKey] = match;
+ const nonComp = {
+ computed: false
+ };
+
+ if (parentKey === "property") {
+ if ((0, _is.default)("MemberExpression", parent, nonComp)) return;
+ if ((0, _is.default)("OptionalMemberExpression", parent, nonComp)) return;
+ } else if (parentKey === "key") {
+ if ((0, _is.default)("Property", parent, nonComp)) return;
+ if ((0, _is.default)("Method", parent, nonComp)) return;
+ } else if (parentKey === "exported") {
+ if ((0, _is.default)("ExportSpecifier", parent)) return;
+ } else if (parentKey === "imported") {
+ if ((0, _is.default)("ImportSpecifier", parent, {
+ imported: node
+ })) return;
+ } else if (parentKey === "meta") {
+ if ((0, _is.default)("MetaProperty", parent, {
+ meta: node
+ })) return;
+ }
+
+ if (((0, _helperValidatorIdentifier.isKeyword)(node.name) || (0, _helperValidatorIdentifier.isReservedWord)(node.name, false)) && node.name !== "this") {
+ throw new TypeError(`"${node.name}" is not a valid identifier`);
+ }
+ }
+
+});
+defineType("IfStatement", {
+ visitor: ["test", "consequent", "alternate"],
+ aliases: ["Statement", "Conditional"],
+ fields: {
+ test: {
+ validate: (0, _utils.assertNodeType)("Expression")
+ },
+ consequent: {
+ validate: (0, _utils.assertNodeType)("Statement")
+ },
+ alternate: {
+ optional: true,
+ validate: (0, _utils.assertNodeType)("Statement")
+ }
+ }
+});
+defineType("LabeledStatement", {
+ visitor: ["label", "body"],
+ aliases: ["Statement"],
+ fields: {
+ label: {
+ validate: (0, _utils.assertNodeType)("Identifier")
+ },
+ body: {
+ validate: (0, _utils.assertNodeType)("Statement")
+ }
+ }
+});
+defineType("StringLiteral", {
+ builder: ["value"],
+ fields: {
+ value: {
+ validate: (0, _utils.assertValueType)("string")
+ }
+ },
+ aliases: ["Expression", "Pureish", "Literal", "Immutable"]
+});
+defineType("NumericLiteral", {
+ builder: ["value"],
+ deprecatedAlias: "NumberLiteral",
+ fields: {
+ value: {
+ validate: (0, _utils.assertValueType)("number")
+ }
+ },
+ aliases: ["Expression", "Pureish", "Literal", "Immutable"]
+});
+defineType("NullLiteral", {
+ aliases: ["Expression", "Pureish", "Literal", "Immutable"]
+});
+defineType("BooleanLiteral", {
+ builder: ["value"],
+ fields: {
+ value: {
+ validate: (0, _utils.assertValueType)("boolean")
+ }
+ },
+ aliases: ["Expression", "Pureish", "Literal", "Immutable"]
+});
+defineType("RegExpLiteral", {
+ builder: ["pattern", "flags"],
+ deprecatedAlias: "RegexLiteral",
+ aliases: ["Expression", "Pureish", "Literal"],
+ fields: {
+ pattern: {
+ validate: (0, _utils.assertValueType)("string")
+ },
+ flags: {
+ validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), Object.assign(function (node, key, val) {
+ if (!process.env.BABEL_TYPES_8_BREAKING) return;
+ const invalid = /[^gimsuy]/.exec(val);
+
+ if (invalid) {
+ throw new TypeError(`"${invalid[0]}" is not a valid RegExp flag`);
+ }
+ }, {
+ type: "string"
+ })),
+ default: ""
+ }
+ }
+});
+defineType("LogicalExpression", {
+ builder: ["operator", "left", "right"],
+ visitor: ["left", "right"],
+ aliases: ["Binary", "Expression"],
+ fields: {
+ operator: {
+ validate: (0, _utils.assertOneOf)(..._constants.LOGICAL_OPERATORS)
+ },
+ left: {
+ validate: (0, _utils.assertNodeType)("Expression")
+ },
+ right: {
+ validate: (0, _utils.assertNodeType)("Expression")
+ }
+ }
+});
+defineType("MemberExpression", {
+ builder: ["object", "property", "computed", ...(!process.env.BABEL_TYPES_8_BREAKING ? ["optional"] : [])],
+ visitor: ["object", "property"],
+ aliases: ["Expression", "LVal"],
+ fields: Object.assign({
+ object: {
+ validate: (0, _utils.assertNodeType)("Expression")
+ },
+ property: {
+ validate: function () {
+ const normal = (0, _utils.assertNodeType)("Identifier", "PrivateName");
+ const computed = (0, _utils.assertNodeType)("Expression");
+
+ const validator = function (node, key, val) {
+ const validator = node.computed ? computed : normal;
+ validator(node, key, val);
+ };
+
+ validator.oneOfNodeTypes = ["Expression", "Identifier", "PrivateName"];
+ return validator;
+ }()
+ },
+ computed: {
+ default: false
+ }
+ }, !process.env.BABEL_TYPES_8_BREAKING ? {
+ optional: {
+ validate: (0, _utils.assertOneOf)(true, false),
+ optional: true
+ }
+ } : {})
+});
+defineType("NewExpression", {
+ inherits: "CallExpression"
+});
+defineType("Program", {
+ visitor: ["directives", "body"],
+ builder: ["body", "directives", "sourceType", "interpreter"],
+ fields: {
+ sourceFile: {
+ validate: (0, _utils.assertValueType)("string")
+ },
+ sourceType: {
+ validate: (0, _utils.assertOneOf)("script", "module"),
+ default: "script"
+ },
+ interpreter: {
+ validate: (0, _utils.assertNodeType)("InterpreterDirective"),
+ default: null,
+ optional: true
+ },
+ directives: {
+ validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Directive"))),
+ default: []
+ },
+ body: {
+ validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Statement")))
+ }
+ },
+ aliases: ["Scopable", "BlockParent", "Block"]
+});
+defineType("ObjectExpression", {
+ visitor: ["properties"],
+ aliases: ["Expression"],
+ fields: {
+ properties: {
+ validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ObjectMethod", "ObjectProperty", "SpreadElement")))
+ }
+ }
+});
+defineType("ObjectMethod", {
+ builder: ["kind", "key", "params", "body", "computed", "generator", "async"],
+ fields: Object.assign({}, functionCommon, functionTypeAnnotationCommon, {
+ kind: Object.assign({
+ validate: (0, _utils.assertOneOf)("method", "get", "set")
+ }, !process.env.BABEL_TYPES_8_BREAKING ? {
+ default: "method"
+ } : {}),
+ computed: {
+ default: false
+ },
+ key: {
+ validate: function () {
+ const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral");
+ const computed = (0, _utils.assertNodeType)("Expression");
+
+ const validator = function (node, key, val) {
+ const validator = node.computed ? computed : normal;
+ validator(node, key, val);
+ };
+
+ validator.oneOfNodeTypes = ["Expression", "Identifier", "StringLiteral", "NumericLiteral"];
+ return validator;
+ }()
+ },
+ decorators: {
+ validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
+ optional: true
+ },
+ body: {
+ validate: (0, _utils.assertNodeType)("BlockStatement")
+ }
+ }),
+ visitor: ["key", "params", "body", "decorators", "returnType", "typeParameters"],
+ aliases: ["UserWhitespacable", "Function", "Scopable", "BlockParent", "FunctionParent", "Method", "ObjectMember"]
+});
+defineType("ObjectProperty", {
+ builder: ["key", "value", "computed", "shorthand", ...(!process.env.BABEL_TYPES_8_BREAKING ? ["decorators"] : [])],
+ fields: {
+ computed: {
+ default: false
+ },
+ key: {
+ validate: function () {
+ const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral");
+ const computed = (0, _utils.assertNodeType)("Expression");
+
+ const validator = function (node, key, val) {
+ const validator = node.computed ? computed : normal;
+ validator(node, key, val);
+ };
+
+ validator.oneOfNodeTypes = ["Expression", "Identifier", "StringLiteral", "NumericLiteral"];
+ return validator;
+ }()
+ },
+ value: {
+ validate: (0, _utils.assertNodeType)("Expression", "PatternLike")
+ },
+ shorthand: {
+ validate: (0, _utils.chain)((0, _utils.assertValueType)("boolean"), Object.assign(function (node, key, val) {
+ if (!process.env.BABEL_TYPES_8_BREAKING) return;
+
+ if (val && node.computed) {
+ throw new TypeError("Property shorthand of ObjectProperty cannot be true if computed is true");
+ }
+ }, {
+ type: "boolean"
+ }), function (node, key, val) {
+ if (!process.env.BABEL_TYPES_8_BREAKING) return;
+
+ if (val && !(0, _is.default)("Identifier", node.key)) {
+ throw new TypeError("Property shorthand of ObjectProperty cannot be true if key is not an Identifier");
+ }
+ }),
+ default: false
+ },
+ decorators: {
+ validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
+ optional: true
+ }
+ },
+ visitor: ["key", "value", "decorators"],
+ aliases: ["UserWhitespacable", "Property", "ObjectMember"],
+ validate: function () {
+ const pattern = (0, _utils.assertNodeType)("Identifier", "Pattern");
+ const expression = (0, _utils.assertNodeType)("Expression");
+ return function (parent, key, node) {
+ if (!process.env.BABEL_TYPES_8_BREAKING) return;
+ const validator = (0, _is.default)("ObjectPattern", parent) ? pattern : expression;
+ validator(node, "value", node.value);
+ };
+ }()
+});
+defineType("RestElement", {
+ visitor: ["argument", "typeAnnotation"],
+ builder: ["argument"],
+ aliases: ["LVal", "PatternLike"],
+ deprecatedAlias: "RestProperty",
+ fields: Object.assign({}, patternLikeCommon, {
+ argument: {
+ validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertNodeType)("LVal") : (0, _utils.assertNodeType)("Identifier", "ArrayPattern", "ObjectPattern", "MemberExpression")
+ },
+ optional: {
+ validate: (0, _utils.assertValueType)("boolean"),
+ optional: true
+ }
+ }),
+
+ validate(parent, key) {
+ if (!process.env.BABEL_TYPES_8_BREAKING) return;
+ const match = /(\w+)\[(\d+)\]/.exec(key);
+ if (!match) throw new Error("Internal Babel error: malformed key.");
+ const [, listKey, index] = match;
+
+ if (parent[listKey].length > index + 1) {
+ throw new TypeError(`RestElement must be last element of ${listKey}`);
+ }
+ }
+
+});
+defineType("ReturnStatement", {
+ visitor: ["argument"],
+ aliases: ["Statement", "Terminatorless", "CompletionStatement"],
+ fields: {
+ argument: {
+ validate: (0, _utils.assertNodeType)("Expression"),
+ optional: true
+ }
+ }
+});
+defineType("SequenceExpression", {
+ visitor: ["expressions"],
+ fields: {
+ expressions: {
+ validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression")))
+ }
+ },
+ aliases: ["Expression"]
+});
+defineType("ParenthesizedExpression", {
+ visitor: ["expression"],
+ aliases: ["Expression", "ExpressionWrapper"],
+ fields: {
+ expression: {
+ validate: (0, _utils.assertNodeType)("Expression")
+ }
+ }
+});
+defineType("SwitchCase", {
+ visitor: ["test", "consequent"],
+ fields: {
+ test: {
+ validate: (0, _utils.assertNodeType)("Expression"),
+ optional: true
+ },
+ consequent: {
+ validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Statement")))
+ }
+ }
+});
+defineType("SwitchStatement", {
+ visitor: ["discriminant", "cases"],
+ aliases: ["Statement", "BlockParent", "Scopable"],
+ fields: {
+ discriminant: {
+ validate: (0, _utils.assertNodeType)("Expression")
+ },
+ cases: {
+ validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("SwitchCase")))
+ }
+ }
+});
+defineType("ThisExpression", {
+ aliases: ["Expression"]
+});
+defineType("ThrowStatement", {
+ visitor: ["argument"],
+ aliases: ["Statement", "Terminatorless", "CompletionStatement"],
+ fields: {
+ argument: {
+ validate: (0, _utils.assertNodeType)("Expression")
+ }
+ }
+});
+defineType("TryStatement", {
+ visitor: ["block", "handler", "finalizer"],
+ aliases: ["Statement"],
+ fields: {
+ block: {
+ validate: (0, _utils.chain)((0, _utils.assertNodeType)("BlockStatement"), Object.assign(function (node) {
+ if (!process.env.BABEL_TYPES_8_BREAKING) return;
+
+ if (!node.handler && !node.finalizer) {
+ throw new TypeError("TryStatement expects either a handler or finalizer, or both");
+ }
+ }, {
+ oneOfNodeTypes: ["BlockStatement"]
+ }))
+ },
+ handler: {
+ optional: true,
+ validate: (0, _utils.assertNodeType)("CatchClause")
+ },
+ finalizer: {
+ optional: true,
+ validate: (0, _utils.assertNodeType)("BlockStatement")
+ }
+ }
+});
+defineType("UnaryExpression", {
+ builder: ["operator", "argument", "prefix"],
+ fields: {
+ prefix: {
+ default: true
+ },
+ argument: {
+ validate: (0, _utils.assertNodeType)("Expression")
+ },
+ operator: {
+ validate: (0, _utils.assertOneOf)(..._constants.UNARY_OPERATORS)
+ }
+ },
+ visitor: ["argument"],
+ aliases: ["UnaryLike", "Expression"]
+});
+defineType("UpdateExpression", {
+ builder: ["operator", "argument", "prefix"],
+ fields: {
+ prefix: {
+ default: false
+ },
+ argument: {
+ validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertNodeType)("Expression") : (0, _utils.assertNodeType)("Identifier", "MemberExpression")
+ },
+ operator: {
+ validate: (0, _utils.assertOneOf)(..._constants.UPDATE_OPERATORS)
+ }
+ },
+ visitor: ["argument"],
+ aliases: ["Expression"]
+});
+defineType("VariableDeclaration", {
+ builder: ["kind", "declarations"],
+ visitor: ["declarations"],
+ aliases: ["Statement", "Declaration"],
+ fields: {
+ declare: {
+ validate: (0, _utils.assertValueType)("boolean"),
+ optional: true
+ },
+ kind: {
+ validate: (0, _utils.assertOneOf)("var", "let", "const")
+ },
+ declarations: {
+ validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("VariableDeclarator")))
+ }
+ },
+
+ validate(parent, key, node) {
+ if (!process.env.BABEL_TYPES_8_BREAKING) return;
+ if (!(0, _is.default)("ForXStatement", parent, {
+ left: node
+ })) return;
+
+ if (node.declarations.length !== 1) {
+ throw new TypeError(`Exactly one VariableDeclarator is required in the VariableDeclaration of a ${parent.type}`);
+ }
+ }
+
+});
+defineType("VariableDeclarator", {
+ visitor: ["id", "init"],
+ fields: {
+ id: {
+ validate: function () {
+ if (!process.env.BABEL_TYPES_8_BREAKING) {
+ return (0, _utils.assertNodeType)("LVal");
+ }
+
+ const normal = (0, _utils.assertNodeType)("Identifier", "ArrayPattern", "ObjectPattern");
+ const without = (0, _utils.assertNodeType)("Identifier");
+ return function (node, key, val) {
+ const validator = node.init ? normal : without;
+ validator(node, key, val);
+ };
+ }()
+ },
+ definite: {
+ optional: true,
+ validate: (0, _utils.assertValueType)("boolean")
+ },
+ init: {
+ optional: true,
+ validate: (0, _utils.assertNodeType)("Expression")
+ }
+ }
+});
+defineType("WhileStatement", {
+ visitor: ["test", "body"],
+ aliases: ["Statement", "BlockParent", "Loop", "While", "Scopable"],
+ fields: {
+ test: {
+ validate: (0, _utils.assertNodeType)("Expression")
+ },
+ body: {
+ validate: (0, _utils.assertNodeType)("Statement")
+ }
+ }
+});
+defineType("WithStatement", {
+ visitor: ["object", "body"],
+ aliases: ["Statement"],
+ fields: {
+ object: {
+ validate: (0, _utils.assertNodeType)("Expression")
+ },
+ body: {
+ validate: (0, _utils.assertNodeType)("Statement")
+ }
+ }
+});
+defineType("AssignmentPattern", {
+ visitor: ["left", "right", "decorators"],
+ builder: ["left", "right"],
+ aliases: ["Pattern", "PatternLike", "LVal"],
+ fields: Object.assign({}, patternLikeCommon, {
+ left: {
+ validate: (0, _utils.assertNodeType)("Identifier", "ObjectPattern", "ArrayPattern", "MemberExpression")
+ },
+ right: {
+ validate: (0, _utils.assertNodeType)("Expression")
+ },
+ decorators: {
+ validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
+ optional: true
+ }
+ })
+});
+defineType("ArrayPattern", {
+ visitor: ["elements", "typeAnnotation"],
+ builder: ["elements"],
+ aliases: ["Pattern", "PatternLike", "LVal"],
+ fields: Object.assign({}, patternLikeCommon, {
+ elements: {
+ validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeOrValueType)("null", "PatternLike")))
+ },
+ decorators: {
+ validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
+ optional: true
+ },
+ optional: {
+ validate: (0, _utils.assertValueType)("boolean"),
+ optional: true
+ }
+ })
+});
+defineType("ArrowFunctionExpression", {
+ builder: ["params", "body", "async"],
+ visitor: ["params", "body", "returnType", "typeParameters"],
+ aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Expression", "Pureish"],
+ fields: Object.assign({}, functionCommon, functionTypeAnnotationCommon, {
+ expression: {
+ validate: (0, _utils.assertValueType)("boolean")
+ },
+ body: {
+ validate: (0, _utils.assertNodeType)("BlockStatement", "Expression")
+ }
+ })
+});
+defineType("ClassBody", {
+ visitor: ["body"],
+ fields: {
+ body: {
+ validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ClassMethod", "ClassPrivateMethod", "ClassProperty", "ClassPrivateProperty", "ClassAccessorProperty", "TSDeclareMethod", "TSIndexSignature", "StaticBlock")))
+ }
+ }
+});
+defineType("ClassExpression", {
+ builder: ["id", "superClass", "body", "decorators"],
+ visitor: ["id", "body", "superClass", "mixins", "typeParameters", "superTypeParameters", "implements", "decorators"],
+ aliases: ["Scopable", "Class", "Expression"],
+ fields: {
+ id: {
+ validate: (0, _utils.assertNodeType)("Identifier"),
+ optional: true
+ },
+ typeParameters: {
+ validate: (0, _utils.assertNodeType)("TypeParameterDeclaration", "TSTypeParameterDeclaration", "Noop"),
+ optional: true
+ },
+ body: {
+ validate: (0, _utils.assertNodeType)("ClassBody")
+ },
+ superClass: {
+ optional: true,
+ validate: (0, _utils.assertNodeType)("Expression")
+ },
+ superTypeParameters: {
+ validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
+ optional: true
+ },
+ implements: {
+ validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSExpressionWithTypeArguments", "ClassImplements"))),
+ optional: true
+ },
+ decorators: {
+ validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
+ optional: true
+ },
+ mixins: {
+ validate: (0, _utils.assertNodeType)("InterfaceExtends"),
+ optional: true
+ }
+ }
+});
+defineType("ClassDeclaration", {
+ inherits: "ClassExpression",
+ aliases: ["Scopable", "Class", "Statement", "Declaration"],
+ fields: {
+ id: {
+ validate: (0, _utils.assertNodeType)("Identifier")
+ },
+ typeParameters: {
+ validate: (0, _utils.assertNodeType)("TypeParameterDeclaration", "TSTypeParameterDeclaration", "Noop"),
+ optional: true
+ },
+ body: {
+ validate: (0, _utils.assertNodeType)("ClassBody")
+ },
+ superClass: {
+ optional: true,
+ validate: (0, _utils.assertNodeType)("Expression")
+ },
+ superTypeParameters: {
+ validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
+ optional: true
+ },
+ implements: {
+ validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSExpressionWithTypeArguments", "ClassImplements"))),
+ optional: true
+ },
+ decorators: {
+ validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
+ optional: true
+ },
+ mixins: {
+ validate: (0, _utils.assertNodeType)("InterfaceExtends"),
+ optional: true
+ },
+ declare: {
+ validate: (0, _utils.assertValueType)("boolean"),
+ optional: true
+ },
+ abstract: {
+ validate: (0, _utils.assertValueType)("boolean"),
+ optional: true
+ }
+ },
+ validate: function () {
+ const identifier = (0, _utils.assertNodeType)("Identifier");
+ return function (parent, key, node) {
+ if (!process.env.BABEL_TYPES_8_BREAKING) return;
+
+ if (!(0, _is.default)("ExportDefaultDeclaration", parent)) {
+ identifier(node, "id", node.id);
+ }
+ };
+ }()
+});
+defineType("ExportAllDeclaration", {
+ visitor: ["source"],
+ aliases: ["Statement", "Declaration", "ModuleDeclaration", "ExportDeclaration"],
+ fields: {
+ source: {
+ validate: (0, _utils.assertNodeType)("StringLiteral")
+ },
+ exportKind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("type", "value")),
+ assertions: {
+ optional: true,
+ validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ImportAttribute")))
+ }
+ }
+});
+defineType("ExportDefaultDeclaration", {
+ visitor: ["declaration"],
+ aliases: ["Statement", "Declaration", "ModuleDeclaration", "ExportDeclaration"],
+ fields: {
+ declaration: {
+ validate: (0, _utils.assertNodeType)("FunctionDeclaration", "TSDeclareFunction", "ClassDeclaration", "Expression")
+ },
+ exportKind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("value"))
+ }
+});
+defineType("ExportNamedDeclaration", {
+ visitor: ["declaration", "specifiers", "source"],
+ aliases: ["Statement", "Declaration", "ModuleDeclaration", "ExportDeclaration"],
+ fields: {
+ declaration: {
+ optional: true,
+ validate: (0, _utils.chain)((0, _utils.assertNodeType)("Declaration"), Object.assign(function (node, key, val) {
+ if (!process.env.BABEL_TYPES_8_BREAKING) return;
+
+ if (val && node.specifiers.length) {
+ throw new TypeError("Only declaration or specifiers is allowed on ExportNamedDeclaration");
+ }
+ }, {
+ oneOfNodeTypes: ["Declaration"]
+ }), function (node, key, val) {
+ if (!process.env.BABEL_TYPES_8_BREAKING) return;
+
+ if (val && node.source) {
+ throw new TypeError("Cannot export a declaration from a source");
+ }
+ })
+ },
+ assertions: {
+ optional: true,
+ validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ImportAttribute")))
+ },
+ specifiers: {
+ default: [],
+ validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)(function () {
+ const sourced = (0, _utils.assertNodeType)("ExportSpecifier", "ExportDefaultSpecifier", "ExportNamespaceSpecifier");
+ const sourceless = (0, _utils.assertNodeType)("ExportSpecifier");
+ if (!process.env.BABEL_TYPES_8_BREAKING) return sourced;
+ return function (node, key, val) {
+ const validator = node.source ? sourced : sourceless;
+ validator(node, key, val);
+ };
+ }()))
+ },
+ source: {
+ validate: (0, _utils.assertNodeType)("StringLiteral"),
+ optional: true
+ },
+ exportKind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("type", "value"))
+ }
+});
+defineType("ExportSpecifier", {
+ visitor: ["local", "exported"],
+ aliases: ["ModuleSpecifier"],
+ fields: {
+ local: {
+ validate: (0, _utils.assertNodeType)("Identifier")
+ },
+ exported: {
+ validate: (0, _utils.assertNodeType)("Identifier", "StringLiteral")
+ },
+ exportKind: {
+ validate: (0, _utils.assertOneOf)("type", "value"),
+ optional: true
+ }
+ }
+});
+defineType("ForOfStatement", {
+ visitor: ["left", "right", "body"],
+ builder: ["left", "right", "body", "await"],
+ aliases: ["Scopable", "Statement", "For", "BlockParent", "Loop", "ForXStatement"],
+ fields: {
+ left: {
+ validate: function () {
+ if (!process.env.BABEL_TYPES_8_BREAKING) {
+ return (0, _utils.assertNodeType)("VariableDeclaration", "LVal");
+ }
+
+ const declaration = (0, _utils.assertNodeType)("VariableDeclaration");
+ const lval = (0, _utils.assertNodeType)("Identifier", "MemberExpression", "ArrayPattern", "ObjectPattern");
+ return function (node, key, val) {
+ if ((0, _is.default)("VariableDeclaration", val)) {
+ declaration(node, key, val);
+ } else {
+ lval(node, key, val);
+ }
+ };
+ }()
+ },
+ right: {
+ validate: (0, _utils.assertNodeType)("Expression")
+ },
+ body: {
+ validate: (0, _utils.assertNodeType)("Statement")
+ },
+ await: {
+ default: false
+ }
+ }
+});
+defineType("ImportDeclaration", {
+ visitor: ["specifiers", "source"],
+ aliases: ["Statement", "Declaration", "ModuleDeclaration"],
+ fields: {
+ assertions: {
+ optional: true,
+ validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ImportAttribute")))
+ },
+ specifiers: {
+ validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ImportSpecifier", "ImportDefaultSpecifier", "ImportNamespaceSpecifier")))
+ },
+ source: {
+ validate: (0, _utils.assertNodeType)("StringLiteral")
+ },
+ importKind: {
+ validate: (0, _utils.assertOneOf)("type", "typeof", "value"),
+ optional: true
+ }
+ }
+});
+defineType("ImportDefaultSpecifier", {
+ visitor: ["local"],
+ aliases: ["ModuleSpecifier"],
+ fields: {
+ local: {
+ validate: (0, _utils.assertNodeType)("Identifier")
+ }
+ }
+});
+defineType("ImportNamespaceSpecifier", {
+ visitor: ["local"],
+ aliases: ["ModuleSpecifier"],
+ fields: {
+ local: {
+ validate: (0, _utils.assertNodeType)("Identifier")
+ }
+ }
+});
+defineType("ImportSpecifier", {
+ visitor: ["local", "imported"],
+ aliases: ["ModuleSpecifier"],
+ fields: {
+ local: {
+ validate: (0, _utils.assertNodeType)("Identifier")
+ },
+ imported: {
+ validate: (0, _utils.assertNodeType)("Identifier", "StringLiteral")
+ },
+ importKind: {
+ validate: (0, _utils.assertOneOf)("type", "typeof", "value"),
+ optional: true
+ }
+ }
+});
+defineType("MetaProperty", {
+ visitor: ["meta", "property"],
+ aliases: ["Expression"],
+ fields: {
+ meta: {
+ validate: (0, _utils.chain)((0, _utils.assertNodeType)("Identifier"), Object.assign(function (node, key, val) {
+ if (!process.env.BABEL_TYPES_8_BREAKING) return;
+ let property;
+
+ switch (val.name) {
+ case "function":
+ property = "sent";
+ break;
+
+ case "new":
+ property = "target";
+ break;
+
+ case "import":
+ property = "meta";
+ break;
+ }
+
+ if (!(0, _is.default)("Identifier", node.property, {
+ name: property
+ })) {
+ throw new TypeError("Unrecognised MetaProperty");
+ }
+ }, {
+ oneOfNodeTypes: ["Identifier"]
+ }))
+ },
+ property: {
+ validate: (0, _utils.assertNodeType)("Identifier")
+ }
+ }
+});
+const classMethodOrPropertyCommon = {
+ abstract: {
+ validate: (0, _utils.assertValueType)("boolean"),
+ optional: true
+ },
+ accessibility: {
+ validate: (0, _utils.assertOneOf)("public", "private", "protected"),
+ optional: true
+ },
+ static: {
+ default: false
+ },
+ override: {
+ default: false
+ },
+ computed: {
+ default: false
+ },
+ optional: {
+ validate: (0, _utils.assertValueType)("boolean"),
+ optional: true
+ },
+ key: {
+ validate: (0, _utils.chain)(function () {
+ const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral");
+ const computed = (0, _utils.assertNodeType)("Expression");
+ return function (node, key, val) {
+ const validator = node.computed ? computed : normal;
+ validator(node, key, val);
+ };
+ }(), (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "Expression"))
+ }
+};
+exports.classMethodOrPropertyCommon = classMethodOrPropertyCommon;
+const classMethodOrDeclareMethodCommon = Object.assign({}, functionCommon, classMethodOrPropertyCommon, {
+ params: {
+ validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Identifier", "Pattern", "RestElement", "TSParameterProperty")))
+ },
+ kind: {
+ validate: (0, _utils.assertOneOf)("get", "set", "method", "constructor"),
+ default: "method"
+ },
+ access: {
+ validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), (0, _utils.assertOneOf)("public", "private", "protected")),
+ optional: true
+ },
+ decorators: {
+ validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
+ optional: true
+ }
+});
+exports.classMethodOrDeclareMethodCommon = classMethodOrDeclareMethodCommon;
+defineType("ClassMethod", {
+ aliases: ["Function", "Scopable", "BlockParent", "FunctionParent", "Method"],
+ builder: ["kind", "key", "params", "body", "computed", "static", "generator", "async"],
+ visitor: ["key", "params", "body", "decorators", "returnType", "typeParameters"],
+ fields: Object.assign({}, classMethodOrDeclareMethodCommon, functionTypeAnnotationCommon, {
+ body: {
+ validate: (0, _utils.assertNodeType)("BlockStatement")
+ }
+ })
+});
+defineType("ObjectPattern", {
+ visitor: ["properties", "typeAnnotation", "decorators"],
+ builder: ["properties"],
+ aliases: ["Pattern", "PatternLike", "LVal"],
+ fields: Object.assign({}, patternLikeCommon, {
+ properties: {
+ validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("RestElement", "ObjectProperty")))
+ }
+ })
+});
+defineType("SpreadElement", {
+ visitor: ["argument"],
+ aliases: ["UnaryLike"],
+ deprecatedAlias: "SpreadProperty",
+ fields: {
+ argument: {
+ validate: (0, _utils.assertNodeType)("Expression")
+ }
+ }
+});
+defineType("Super", {
+ aliases: ["Expression"]
+});
+defineType("TaggedTemplateExpression", {
+ visitor: ["tag", "quasi", "typeParameters"],
+ builder: ["tag", "quasi"],
+ aliases: ["Expression"],
+ fields: {
+ tag: {
+ validate: (0, _utils.assertNodeType)("Expression")
+ },
+ quasi: {
+ validate: (0, _utils.assertNodeType)("TemplateLiteral")
+ },
+ typeParameters: {
+ validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
+ optional: true
+ }
+ }
+});
+defineType("TemplateElement", {
+ builder: ["value", "tail"],
+ fields: {
+ value: {
+ validate: (0, _utils.assertShape)({
+ raw: {
+ validate: (0, _utils.assertValueType)("string")
+ },
+ cooked: {
+ validate: (0, _utils.assertValueType)("string"),
+ optional: true
+ }
+ })
+ },
+ tail: {
+ default: false
+ }
+ }
+});
+defineType("TemplateLiteral", {
+ visitor: ["quasis", "expressions"],
+ aliases: ["Expression", "Literal"],
+ fields: {
+ quasis: {
+ validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TemplateElement")))
+ },
+ expressions: {
+ validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression", "TSType")), function (node, key, val) {
+ if (node.quasis.length !== val.length + 1) {
+ throw new TypeError(`Number of ${node.type} quasis should be exactly one more than the number of expressions.\nExpected ${val.length + 1} quasis but got ${node.quasis.length}`);
+ }
+ })
+ }
+ }
+});
+defineType("YieldExpression", {
+ builder: ["argument", "delegate"],
+ visitor: ["argument"],
+ aliases: ["Expression", "Terminatorless"],
+ fields: {
+ delegate: {
+ validate: (0, _utils.chain)((0, _utils.assertValueType)("boolean"), Object.assign(function (node, key, val) {
+ if (!process.env.BABEL_TYPES_8_BREAKING) return;
+
+ if (val && !node.argument) {
+ throw new TypeError("Property delegate of YieldExpression cannot be true if there is no argument");
+ }
+ }, {
+ type: "boolean"
+ })),
+ default: false
+ },
+ argument: {
+ optional: true,
+ validate: (0, _utils.assertNodeType)("Expression")
+ }
+ }
+});
+defineType("AwaitExpression", {
+ builder: ["argument"],
+ visitor: ["argument"],
+ aliases: ["Expression", "Terminatorless"],
+ fields: {
+ argument: {
+ validate: (0, _utils.assertNodeType)("Expression")
+ }
+ }
+});
+defineType("Import", {
+ aliases: ["Expression"]
+});
+defineType("BigIntLiteral", {
+ builder: ["value"],
+ fields: {
+ value: {
+ validate: (0, _utils.assertValueType)("string")
+ }
+ },
+ aliases: ["Expression", "Pureish", "Literal", "Immutable"]
+});
+defineType("ExportNamespaceSpecifier", {
+ visitor: ["exported"],
+ aliases: ["ModuleSpecifier"],
+ fields: {
+ exported: {
+ validate: (0, _utils.assertNodeType)("Identifier")
+ }
+ }
+});
+defineType("OptionalMemberExpression", {
+ builder: ["object", "property", "computed", "optional"],
+ visitor: ["object", "property"],
+ aliases: ["Expression"],
+ fields: {
+ object: {
+ validate: (0, _utils.assertNodeType)("Expression")
+ },
+ property: {
+ validate: function () {
+ const normal = (0, _utils.assertNodeType)("Identifier");
+ const computed = (0, _utils.assertNodeType)("Expression");
+
+ const validator = function (node, key, val) {
+ const validator = node.computed ? computed : normal;
+ validator(node, key, val);
+ };
+
+ validator.oneOfNodeTypes = ["Expression", "Identifier"];
+ return validator;
+ }()
+ },
+ computed: {
+ default: false
+ },
+ optional: {
+ validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertValueType)("boolean") : (0, _utils.chain)((0, _utils.assertValueType)("boolean"), (0, _utils.assertOptionalChainStart)())
+ }
+ }
+});
+defineType("OptionalCallExpression", {
+ visitor: ["callee", "arguments", "typeParameters", "typeArguments"],
+ builder: ["callee", "arguments", "optional"],
+ aliases: ["Expression"],
+ fields: {
+ callee: {
+ validate: (0, _utils.assertNodeType)("Expression")
+ },
+ arguments: {
+ validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression", "SpreadElement", "JSXNamespacedName", "ArgumentPlaceholder")))
+ },
+ optional: {
+ validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertValueType)("boolean") : (0, _utils.chain)((0, _utils.assertValueType)("boolean"), (0, _utils.assertOptionalChainStart)())
+ },
+ typeArguments: {
+ validate: (0, _utils.assertNodeType)("TypeParameterInstantiation"),
+ optional: true
+ },
+ typeParameters: {
+ validate: (0, _utils.assertNodeType)("TSTypeParameterInstantiation"),
+ optional: true
+ }
+ }
+});
+defineType("ClassProperty", {
+ visitor: ["key", "value", "typeAnnotation", "decorators"],
+ builder: ["key", "value", "typeAnnotation", "decorators", "computed", "static"],
+ aliases: ["Property"],
+ fields: Object.assign({}, classMethodOrPropertyCommon, {
+ value: {
+ validate: (0, _utils.assertNodeType)("Expression"),
+ optional: true
+ },
+ definite: {
+ validate: (0, _utils.assertValueType)("boolean"),
+ optional: true
+ },
+ typeAnnotation: {
+ validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"),
+ optional: true
+ },
+ decorators: {
+ validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
+ optional: true
+ },
+ readonly: {
+ validate: (0, _utils.assertValueType)("boolean"),
+ optional: true
+ },
+ declare: {
+ validate: (0, _utils.assertValueType)("boolean"),
+ optional: true
+ },
+ variance: {
+ validate: (0, _utils.assertNodeType)("Variance"),
+ optional: true
+ }
+ })
+});
+defineType("ClassAccessorProperty", {
+ visitor: ["key", "value", "typeAnnotation", "decorators"],
+ builder: ["key", "value", "typeAnnotation", "decorators", "computed", "static"],
+ aliases: ["Property", "Accessor"],
+ fields: Object.assign({}, classMethodOrPropertyCommon, {
+ key: {
+ validate: (0, _utils.chain)(function () {
+ const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "PrivateName");
+ const computed = (0, _utils.assertNodeType)("Expression");
+ return function (node, key, val) {
+ const validator = node.computed ? computed : normal;
+ validator(node, key, val);
+ };
+ }(), (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "Expression", "PrivateName"))
+ },
+ value: {
+ validate: (0, _utils.assertNodeType)("Expression"),
+ optional: true
+ },
+ definite: {
+ validate: (0, _utils.assertValueType)("boolean"),
+ optional: true
+ },
+ typeAnnotation: {
+ validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"),
+ optional: true
+ },
+ decorators: {
+ validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
+ optional: true
+ },
+ readonly: {
+ validate: (0, _utils.assertValueType)("boolean"),
+ optional: true
+ },
+ declare: {
+ validate: (0, _utils.assertValueType)("boolean"),
+ optional: true
+ },
+ variance: {
+ validate: (0, _utils.assertNodeType)("Variance"),
+ optional: true
+ }
+ })
+});
+defineType("ClassPrivateProperty", {
+ visitor: ["key", "value", "decorators", "typeAnnotation"],
+ builder: ["key", "value", "decorators", "static"],
+ aliases: ["Property", "Private"],
+ fields: {
+ key: {
+ validate: (0, _utils.assertNodeType)("PrivateName")
+ },
+ value: {
+ validate: (0, _utils.assertNodeType)("Expression"),
+ optional: true
+ },
+ typeAnnotation: {
+ validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"),
+ optional: true
+ },
+ decorators: {
+ validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
+ optional: true
+ },
+ readonly: {
+ validate: (0, _utils.assertValueType)("boolean"),
+ optional: true
+ },
+ definite: {
+ validate: (0, _utils.assertValueType)("boolean"),
+ optional: true
+ },
+ variance: {
+ validate: (0, _utils.assertNodeType)("Variance"),
+ optional: true
+ }
+ }
+});
+defineType("ClassPrivateMethod", {
+ builder: ["kind", "key", "params", "body", "static"],
+ visitor: ["key", "params", "body", "decorators", "returnType", "typeParameters"],
+ aliases: ["Function", "Scopable", "BlockParent", "FunctionParent", "Method", "Private"],
+ fields: Object.assign({}, classMethodOrDeclareMethodCommon, functionTypeAnnotationCommon, {
+ key: {
+ validate: (0, _utils.assertNodeType)("PrivateName")
+ },
+ body: {
+ validate: (0, _utils.assertNodeType)("BlockStatement")
+ }
+ })
+});
+defineType("PrivateName", {
+ visitor: ["id"],
+ aliases: ["Private"],
+ fields: {
+ id: {
+ validate: (0, _utils.assertNodeType)("Identifier")
+ }
+ }
+});
+defineType("StaticBlock", {
+ visitor: ["body"],
+ fields: {
+ body: {
+ validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Statement")))
+ }
+ },
+ aliases: ["Scopable", "BlockParent", "FunctionParent"]
+});
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/definitions/experimental.js b/node_modules/@babel/types/lib/definitions/experimental.js
new file mode 100644
index 000000000..be97c0d79
--- /dev/null
+++ b/node_modules/@babel/types/lib/definitions/experimental.js
@@ -0,0 +1,133 @@
+"use strict";
+
+var _utils = require("./utils");
+
+(0, _utils.default)("ArgumentPlaceholder", {});
+(0, _utils.default)("BindExpression", {
+ visitor: ["object", "callee"],
+ aliases: ["Expression"],
+ fields: !process.env.BABEL_TYPES_8_BREAKING ? {
+ object: {
+ validate: Object.assign(() => {}, {
+ oneOfNodeTypes: ["Expression"]
+ })
+ },
+ callee: {
+ validate: Object.assign(() => {}, {
+ oneOfNodeTypes: ["Expression"]
+ })
+ }
+ } : {
+ object: {
+ validate: (0, _utils.assertNodeType)("Expression")
+ },
+ callee: {
+ validate: (0, _utils.assertNodeType)("Expression")
+ }
+ }
+});
+(0, _utils.default)("ImportAttribute", {
+ visitor: ["key", "value"],
+ fields: {
+ key: {
+ validate: (0, _utils.assertNodeType)("Identifier", "StringLiteral")
+ },
+ value: {
+ validate: (0, _utils.assertNodeType)("StringLiteral")
+ }
+ }
+});
+(0, _utils.default)("Decorator", {
+ visitor: ["expression"],
+ fields: {
+ expression: {
+ validate: (0, _utils.assertNodeType)("Expression")
+ }
+ }
+});
+(0, _utils.default)("DoExpression", {
+ visitor: ["body"],
+ builder: ["body", "async"],
+ aliases: ["Expression"],
+ fields: {
+ body: {
+ validate: (0, _utils.assertNodeType)("BlockStatement")
+ },
+ async: {
+ validate: (0, _utils.assertValueType)("boolean"),
+ default: false
+ }
+ }
+});
+(0, _utils.default)("ExportDefaultSpecifier", {
+ visitor: ["exported"],
+ aliases: ["ModuleSpecifier"],
+ fields: {
+ exported: {
+ validate: (0, _utils.assertNodeType)("Identifier")
+ }
+ }
+});
+(0, _utils.default)("RecordExpression", {
+ visitor: ["properties"],
+ aliases: ["Expression"],
+ fields: {
+ properties: {
+ validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ObjectProperty", "SpreadElement")))
+ }
+ }
+});
+(0, _utils.default)("TupleExpression", {
+ fields: {
+ elements: {
+ validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression", "SpreadElement"))),
+ default: []
+ }
+ },
+ visitor: ["elements"],
+ aliases: ["Expression"]
+});
+(0, _utils.default)("DecimalLiteral", {
+ builder: ["value"],
+ fields: {
+ value: {
+ validate: (0, _utils.assertValueType)("string")
+ }
+ },
+ aliases: ["Expression", "Pureish", "Literal", "Immutable"]
+});
+(0, _utils.default)("ModuleExpression", {
+ visitor: ["body"],
+ fields: {
+ body: {
+ validate: (0, _utils.assertNodeType)("Program")
+ }
+ },
+ aliases: ["Expression"]
+});
+(0, _utils.default)("TopicReference", {
+ aliases: ["Expression"]
+});
+(0, _utils.default)("PipelineTopicExpression", {
+ builder: ["expression"],
+ visitor: ["expression"],
+ fields: {
+ expression: {
+ validate: (0, _utils.assertNodeType)("Expression")
+ }
+ },
+ aliases: ["Expression"]
+});
+(0, _utils.default)("PipelineBareFunction", {
+ builder: ["callee"],
+ visitor: ["callee"],
+ fields: {
+ callee: {
+ validate: (0, _utils.assertNodeType)("Expression")
+ }
+ },
+ aliases: ["Expression"]
+});
+(0, _utils.default)("PipelinePrimaryTopicReference", {
+ aliases: ["Expression"]
+});
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/definitions/flow.js b/node_modules/@babel/types/lib/definitions/flow.js
new file mode 100644
index 000000000..706de2425
--- /dev/null
+++ b/node_modules/@babel/types/lib/definitions/flow.js
@@ -0,0 +1,474 @@
+"use strict";
+
+var _utils = require("./utils");
+
+const defineType = (0, _utils.defineAliasedType)("Flow");
+
+const defineInterfaceishType = (name, typeParameterType = "TypeParameterDeclaration") => {
+ defineType(name, {
+ builder: ["id", "typeParameters", "extends", "body"],
+ visitor: ["id", "typeParameters", "extends", "mixins", "implements", "body"],
+ aliases: ["FlowDeclaration", "Statement", "Declaration"],
+ fields: {
+ id: (0, _utils.validateType)("Identifier"),
+ typeParameters: (0, _utils.validateOptionalType)(typeParameterType),
+ extends: (0, _utils.validateOptional)((0, _utils.arrayOfType)("InterfaceExtends")),
+ mixins: (0, _utils.validateOptional)((0, _utils.arrayOfType)("InterfaceExtends")),
+ implements: (0, _utils.validateOptional)((0, _utils.arrayOfType)("ClassImplements")),
+ body: (0, _utils.validateType)("ObjectTypeAnnotation")
+ }
+ });
+};
+
+defineType("AnyTypeAnnotation", {
+ aliases: ["FlowType", "FlowBaseAnnotation"]
+});
+defineType("ArrayTypeAnnotation", {
+ visitor: ["elementType"],
+ aliases: ["FlowType"],
+ fields: {
+ elementType: (0, _utils.validateType)("FlowType")
+ }
+});
+defineType("BooleanTypeAnnotation", {
+ aliases: ["FlowType", "FlowBaseAnnotation"]
+});
+defineType("BooleanLiteralTypeAnnotation", {
+ builder: ["value"],
+ aliases: ["FlowType"],
+ fields: {
+ value: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
+ }
+});
+defineType("NullLiteralTypeAnnotation", {
+ aliases: ["FlowType", "FlowBaseAnnotation"]
+});
+defineType("ClassImplements", {
+ visitor: ["id", "typeParameters"],
+ fields: {
+ id: (0, _utils.validateType)("Identifier"),
+ typeParameters: (0, _utils.validateOptionalType)("TypeParameterInstantiation")
+ }
+});
+defineInterfaceishType("DeclareClass");
+defineType("DeclareFunction", {
+ visitor: ["id"],
+ aliases: ["FlowDeclaration", "Statement", "Declaration"],
+ fields: {
+ id: (0, _utils.validateType)("Identifier"),
+ predicate: (0, _utils.validateOptionalType)("DeclaredPredicate")
+ }
+});
+defineInterfaceishType("DeclareInterface");
+defineType("DeclareModule", {
+ builder: ["id", "body", "kind"],
+ visitor: ["id", "body"],
+ aliases: ["FlowDeclaration", "Statement", "Declaration"],
+ fields: {
+ id: (0, _utils.validateType)(["Identifier", "StringLiteral"]),
+ body: (0, _utils.validateType)("BlockStatement"),
+ kind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("CommonJS", "ES"))
+ }
+});
+defineType("DeclareModuleExports", {
+ visitor: ["typeAnnotation"],
+ aliases: ["FlowDeclaration", "Statement", "Declaration"],
+ fields: {
+ typeAnnotation: (0, _utils.validateType)("TypeAnnotation")
+ }
+});
+defineType("DeclareTypeAlias", {
+ visitor: ["id", "typeParameters", "right"],
+ aliases: ["FlowDeclaration", "Statement", "Declaration"],
+ fields: {
+ id: (0, _utils.validateType)("Identifier"),
+ typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
+ right: (0, _utils.validateType)("FlowType")
+ }
+});
+defineType("DeclareOpaqueType", {
+ visitor: ["id", "typeParameters", "supertype"],
+ aliases: ["FlowDeclaration", "Statement", "Declaration"],
+ fields: {
+ id: (0, _utils.validateType)("Identifier"),
+ typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
+ supertype: (0, _utils.validateOptionalType)("FlowType"),
+ impltype: (0, _utils.validateOptionalType)("FlowType")
+ }
+});
+defineType("DeclareVariable", {
+ visitor: ["id"],
+ aliases: ["FlowDeclaration", "Statement", "Declaration"],
+ fields: {
+ id: (0, _utils.validateType)("Identifier")
+ }
+});
+defineType("DeclareExportDeclaration", {
+ visitor: ["declaration", "specifiers", "source"],
+ aliases: ["FlowDeclaration", "Statement", "Declaration"],
+ fields: {
+ declaration: (0, _utils.validateOptionalType)("Flow"),
+ specifiers: (0, _utils.validateOptional)((0, _utils.arrayOfType)(["ExportSpecifier", "ExportNamespaceSpecifier"])),
+ source: (0, _utils.validateOptionalType)("StringLiteral"),
+ default: (0, _utils.validateOptional)((0, _utils.assertValueType)("boolean"))
+ }
+});
+defineType("DeclareExportAllDeclaration", {
+ visitor: ["source"],
+ aliases: ["FlowDeclaration", "Statement", "Declaration"],
+ fields: {
+ source: (0, _utils.validateType)("StringLiteral"),
+ exportKind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("type", "value"))
+ }
+});
+defineType("DeclaredPredicate", {
+ visitor: ["value"],
+ aliases: ["FlowPredicate"],
+ fields: {
+ value: (0, _utils.validateType)("Flow")
+ }
+});
+defineType("ExistsTypeAnnotation", {
+ aliases: ["FlowType"]
+});
+defineType("FunctionTypeAnnotation", {
+ visitor: ["typeParameters", "params", "rest", "returnType"],
+ aliases: ["FlowType"],
+ fields: {
+ typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
+ params: (0, _utils.validate)((0, _utils.arrayOfType)("FunctionTypeParam")),
+ rest: (0, _utils.validateOptionalType)("FunctionTypeParam"),
+ this: (0, _utils.validateOptionalType)("FunctionTypeParam"),
+ returnType: (0, _utils.validateType)("FlowType")
+ }
+});
+defineType("FunctionTypeParam", {
+ visitor: ["name", "typeAnnotation"],
+ fields: {
+ name: (0, _utils.validateOptionalType)("Identifier"),
+ typeAnnotation: (0, _utils.validateType)("FlowType"),
+ optional: (0, _utils.validateOptional)((0, _utils.assertValueType)("boolean"))
+ }
+});
+defineType("GenericTypeAnnotation", {
+ visitor: ["id", "typeParameters"],
+ aliases: ["FlowType"],
+ fields: {
+ id: (0, _utils.validateType)(["Identifier", "QualifiedTypeIdentifier"]),
+ typeParameters: (0, _utils.validateOptionalType)("TypeParameterInstantiation")
+ }
+});
+defineType("InferredPredicate", {
+ aliases: ["FlowPredicate"]
+});
+defineType("InterfaceExtends", {
+ visitor: ["id", "typeParameters"],
+ fields: {
+ id: (0, _utils.validateType)(["Identifier", "QualifiedTypeIdentifier"]),
+ typeParameters: (0, _utils.validateOptionalType)("TypeParameterInstantiation")
+ }
+});
+defineInterfaceishType("InterfaceDeclaration");
+defineType("InterfaceTypeAnnotation", {
+ visitor: ["extends", "body"],
+ aliases: ["FlowType"],
+ fields: {
+ extends: (0, _utils.validateOptional)((0, _utils.arrayOfType)("InterfaceExtends")),
+ body: (0, _utils.validateType)("ObjectTypeAnnotation")
+ }
+});
+defineType("IntersectionTypeAnnotation", {
+ visitor: ["types"],
+ aliases: ["FlowType"],
+ fields: {
+ types: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType"))
+ }
+});
+defineType("MixedTypeAnnotation", {
+ aliases: ["FlowType", "FlowBaseAnnotation"]
+});
+defineType("EmptyTypeAnnotation", {
+ aliases: ["FlowType", "FlowBaseAnnotation"]
+});
+defineType("NullableTypeAnnotation", {
+ visitor: ["typeAnnotation"],
+ aliases: ["FlowType"],
+ fields: {
+ typeAnnotation: (0, _utils.validateType)("FlowType")
+ }
+});
+defineType("NumberLiteralTypeAnnotation", {
+ builder: ["value"],
+ aliases: ["FlowType"],
+ fields: {
+ value: (0, _utils.validate)((0, _utils.assertValueType)("number"))
+ }
+});
+defineType("NumberTypeAnnotation", {
+ aliases: ["FlowType", "FlowBaseAnnotation"]
+});
+defineType("ObjectTypeAnnotation", {
+ visitor: ["properties", "indexers", "callProperties", "internalSlots"],
+ aliases: ["FlowType"],
+ builder: ["properties", "indexers", "callProperties", "internalSlots", "exact"],
+ fields: {
+ properties: (0, _utils.validate)((0, _utils.arrayOfType)(["ObjectTypeProperty", "ObjectTypeSpreadProperty"])),
+ indexers: (0, _utils.validateOptional)((0, _utils.arrayOfType)("ObjectTypeIndexer")),
+ callProperties: (0, _utils.validateOptional)((0, _utils.arrayOfType)("ObjectTypeCallProperty")),
+ internalSlots: (0, _utils.validateOptional)((0, _utils.arrayOfType)("ObjectTypeInternalSlot")),
+ exact: {
+ validate: (0, _utils.assertValueType)("boolean"),
+ default: false
+ },
+ inexact: (0, _utils.validateOptional)((0, _utils.assertValueType)("boolean"))
+ }
+});
+defineType("ObjectTypeInternalSlot", {
+ visitor: ["id", "value", "optional", "static", "method"],
+ aliases: ["UserWhitespacable"],
+ fields: {
+ id: (0, _utils.validateType)("Identifier"),
+ value: (0, _utils.validateType)("FlowType"),
+ optional: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
+ static: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
+ method: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
+ }
+});
+defineType("ObjectTypeCallProperty", {
+ visitor: ["value"],
+ aliases: ["UserWhitespacable"],
+ fields: {
+ value: (0, _utils.validateType)("FlowType"),
+ static: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
+ }
+});
+defineType("ObjectTypeIndexer", {
+ visitor: ["id", "key", "value", "variance"],
+ aliases: ["UserWhitespacable"],
+ fields: {
+ id: (0, _utils.validateOptionalType)("Identifier"),
+ key: (0, _utils.validateType)("FlowType"),
+ value: (0, _utils.validateType)("FlowType"),
+ static: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
+ variance: (0, _utils.validateOptionalType)("Variance")
+ }
+});
+defineType("ObjectTypeProperty", {
+ visitor: ["key", "value", "variance"],
+ aliases: ["UserWhitespacable"],
+ fields: {
+ key: (0, _utils.validateType)(["Identifier", "StringLiteral"]),
+ value: (0, _utils.validateType)("FlowType"),
+ kind: (0, _utils.validate)((0, _utils.assertOneOf)("init", "get", "set")),
+ static: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
+ proto: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
+ optional: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
+ variance: (0, _utils.validateOptionalType)("Variance"),
+ method: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
+ }
+});
+defineType("ObjectTypeSpreadProperty", {
+ visitor: ["argument"],
+ aliases: ["UserWhitespacable"],
+ fields: {
+ argument: (0, _utils.validateType)("FlowType")
+ }
+});
+defineType("OpaqueType", {
+ visitor: ["id", "typeParameters", "supertype", "impltype"],
+ aliases: ["FlowDeclaration", "Statement", "Declaration"],
+ fields: {
+ id: (0, _utils.validateType)("Identifier"),
+ typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
+ supertype: (0, _utils.validateOptionalType)("FlowType"),
+ impltype: (0, _utils.validateType)("FlowType")
+ }
+});
+defineType("QualifiedTypeIdentifier", {
+ visitor: ["id", "qualification"],
+ fields: {
+ id: (0, _utils.validateType)("Identifier"),
+ qualification: (0, _utils.validateType)(["Identifier", "QualifiedTypeIdentifier"])
+ }
+});
+defineType("StringLiteralTypeAnnotation", {
+ builder: ["value"],
+ aliases: ["FlowType"],
+ fields: {
+ value: (0, _utils.validate)((0, _utils.assertValueType)("string"))
+ }
+});
+defineType("StringTypeAnnotation", {
+ aliases: ["FlowType", "FlowBaseAnnotation"]
+});
+defineType("SymbolTypeAnnotation", {
+ aliases: ["FlowType", "FlowBaseAnnotation"]
+});
+defineType("ThisTypeAnnotation", {
+ aliases: ["FlowType", "FlowBaseAnnotation"]
+});
+defineType("TupleTypeAnnotation", {
+ visitor: ["types"],
+ aliases: ["FlowType"],
+ fields: {
+ types: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType"))
+ }
+});
+defineType("TypeofTypeAnnotation", {
+ visitor: ["argument"],
+ aliases: ["FlowType"],
+ fields: {
+ argument: (0, _utils.validateType)("FlowType")
+ }
+});
+defineType("TypeAlias", {
+ visitor: ["id", "typeParameters", "right"],
+ aliases: ["FlowDeclaration", "Statement", "Declaration"],
+ fields: {
+ id: (0, _utils.validateType)("Identifier"),
+ typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
+ right: (0, _utils.validateType)("FlowType")
+ }
+});
+defineType("TypeAnnotation", {
+ visitor: ["typeAnnotation"],
+ fields: {
+ typeAnnotation: (0, _utils.validateType)("FlowType")
+ }
+});
+defineType("TypeCastExpression", {
+ visitor: ["expression", "typeAnnotation"],
+ aliases: ["ExpressionWrapper", "Expression"],
+ fields: {
+ expression: (0, _utils.validateType)("Expression"),
+ typeAnnotation: (0, _utils.validateType)("TypeAnnotation")
+ }
+});
+defineType("TypeParameter", {
+ visitor: ["bound", "default", "variance"],
+ fields: {
+ name: (0, _utils.validate)((0, _utils.assertValueType)("string")),
+ bound: (0, _utils.validateOptionalType)("TypeAnnotation"),
+ default: (0, _utils.validateOptionalType)("FlowType"),
+ variance: (0, _utils.validateOptionalType)("Variance")
+ }
+});
+defineType("TypeParameterDeclaration", {
+ visitor: ["params"],
+ fields: {
+ params: (0, _utils.validate)((0, _utils.arrayOfType)("TypeParameter"))
+ }
+});
+defineType("TypeParameterInstantiation", {
+ visitor: ["params"],
+ fields: {
+ params: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType"))
+ }
+});
+defineType("UnionTypeAnnotation", {
+ visitor: ["types"],
+ aliases: ["FlowType"],
+ fields: {
+ types: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType"))
+ }
+});
+defineType("Variance", {
+ builder: ["kind"],
+ fields: {
+ kind: (0, _utils.validate)((0, _utils.assertOneOf)("minus", "plus"))
+ }
+});
+defineType("VoidTypeAnnotation", {
+ aliases: ["FlowType", "FlowBaseAnnotation"]
+});
+defineType("EnumDeclaration", {
+ aliases: ["Statement", "Declaration"],
+ visitor: ["id", "body"],
+ fields: {
+ id: (0, _utils.validateType)("Identifier"),
+ body: (0, _utils.validateType)(["EnumBooleanBody", "EnumNumberBody", "EnumStringBody", "EnumSymbolBody"])
+ }
+});
+defineType("EnumBooleanBody", {
+ aliases: ["EnumBody"],
+ visitor: ["members"],
+ fields: {
+ explicitType: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
+ members: (0, _utils.validateArrayOfType)("EnumBooleanMember"),
+ hasUnknownMembers: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
+ }
+});
+defineType("EnumNumberBody", {
+ aliases: ["EnumBody"],
+ visitor: ["members"],
+ fields: {
+ explicitType: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
+ members: (0, _utils.validateArrayOfType)("EnumNumberMember"),
+ hasUnknownMembers: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
+ }
+});
+defineType("EnumStringBody", {
+ aliases: ["EnumBody"],
+ visitor: ["members"],
+ fields: {
+ explicitType: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
+ members: (0, _utils.validateArrayOfType)(["EnumStringMember", "EnumDefaultedMember"]),
+ hasUnknownMembers: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
+ }
+});
+defineType("EnumSymbolBody", {
+ aliases: ["EnumBody"],
+ visitor: ["members"],
+ fields: {
+ members: (0, _utils.validateArrayOfType)("EnumDefaultedMember"),
+ hasUnknownMembers: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
+ }
+});
+defineType("EnumBooleanMember", {
+ aliases: ["EnumMember"],
+ visitor: ["id"],
+ fields: {
+ id: (0, _utils.validateType)("Identifier"),
+ init: (0, _utils.validateType)("BooleanLiteral")
+ }
+});
+defineType("EnumNumberMember", {
+ aliases: ["EnumMember"],
+ visitor: ["id", "init"],
+ fields: {
+ id: (0, _utils.validateType)("Identifier"),
+ init: (0, _utils.validateType)("NumericLiteral")
+ }
+});
+defineType("EnumStringMember", {
+ aliases: ["EnumMember"],
+ visitor: ["id", "init"],
+ fields: {
+ id: (0, _utils.validateType)("Identifier"),
+ init: (0, _utils.validateType)("StringLiteral")
+ }
+});
+defineType("EnumDefaultedMember", {
+ aliases: ["EnumMember"],
+ visitor: ["id"],
+ fields: {
+ id: (0, _utils.validateType)("Identifier")
+ }
+});
+defineType("IndexedAccessType", {
+ visitor: ["objectType", "indexType"],
+ aliases: ["FlowType"],
+ fields: {
+ objectType: (0, _utils.validateType)("FlowType"),
+ indexType: (0, _utils.validateType)("FlowType")
+ }
+});
+defineType("OptionalIndexedAccessType", {
+ visitor: ["objectType", "indexType"],
+ aliases: ["FlowType"],
+ fields: {
+ objectType: (0, _utils.validateType)("FlowType"),
+ indexType: (0, _utils.validateType)("FlowType"),
+ optional: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
+ }
+});
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/definitions/index.js b/node_modules/@babel/types/lib/definitions/index.js
new file mode 100644
index 000000000..9b7c92cfe
--- /dev/null
+++ b/node_modules/@babel/types/lib/definitions/index.js
@@ -0,0 +1,103 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+Object.defineProperty(exports, "ALIAS_KEYS", {
+ enumerable: true,
+ get: function () {
+ return _utils.ALIAS_KEYS;
+ }
+});
+Object.defineProperty(exports, "BUILDER_KEYS", {
+ enumerable: true,
+ get: function () {
+ return _utils.BUILDER_KEYS;
+ }
+});
+Object.defineProperty(exports, "DEPRECATED_KEYS", {
+ enumerable: true,
+ get: function () {
+ return _utils.DEPRECATED_KEYS;
+ }
+});
+Object.defineProperty(exports, "FLIPPED_ALIAS_KEYS", {
+ enumerable: true,
+ get: function () {
+ return _utils.FLIPPED_ALIAS_KEYS;
+ }
+});
+Object.defineProperty(exports, "NODE_FIELDS", {
+ enumerable: true,
+ get: function () {
+ return _utils.NODE_FIELDS;
+ }
+});
+Object.defineProperty(exports, "NODE_PARENT_VALIDATIONS", {
+ enumerable: true,
+ get: function () {
+ return _utils.NODE_PARENT_VALIDATIONS;
+ }
+});
+Object.defineProperty(exports, "PLACEHOLDERS", {
+ enumerable: true,
+ get: function () {
+ return _placeholders.PLACEHOLDERS;
+ }
+});
+Object.defineProperty(exports, "PLACEHOLDERS_ALIAS", {
+ enumerable: true,
+ get: function () {
+ return _placeholders.PLACEHOLDERS_ALIAS;
+ }
+});
+Object.defineProperty(exports, "PLACEHOLDERS_FLIPPED_ALIAS", {
+ enumerable: true,
+ get: function () {
+ return _placeholders.PLACEHOLDERS_FLIPPED_ALIAS;
+ }
+});
+exports.TYPES = void 0;
+Object.defineProperty(exports, "VISITOR_KEYS", {
+ enumerable: true,
+ get: function () {
+ return _utils.VISITOR_KEYS;
+ }
+});
+
+var _toFastProperties = require("to-fast-properties");
+
+require("./core");
+
+require("./flow");
+
+require("./jsx");
+
+require("./misc");
+
+require("./experimental");
+
+require("./typescript");
+
+var _utils = require("./utils");
+
+var _placeholders = require("./placeholders");
+
+_toFastProperties(_utils.VISITOR_KEYS);
+
+_toFastProperties(_utils.ALIAS_KEYS);
+
+_toFastProperties(_utils.FLIPPED_ALIAS_KEYS);
+
+_toFastProperties(_utils.NODE_FIELDS);
+
+_toFastProperties(_utils.BUILDER_KEYS);
+
+_toFastProperties(_utils.DEPRECATED_KEYS);
+
+_toFastProperties(_placeholders.PLACEHOLDERS_ALIAS);
+
+_toFastProperties(_placeholders.PLACEHOLDERS_FLIPPED_ALIAS);
+
+const TYPES = [].concat(Object.keys(_utils.VISITOR_KEYS), Object.keys(_utils.FLIPPED_ALIAS_KEYS), Object.keys(_utils.DEPRECATED_KEYS));
+exports.TYPES = TYPES;
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/definitions/jsx.js b/node_modules/@babel/types/lib/definitions/jsx.js
new file mode 100644
index 000000000..4d7fb75f7
--- /dev/null
+++ b/node_modules/@babel/types/lib/definitions/jsx.js
@@ -0,0 +1,156 @@
+"use strict";
+
+var _utils = require("./utils");
+
+const defineType = (0, _utils.defineAliasedType)("JSX");
+defineType("JSXAttribute", {
+ visitor: ["name", "value"],
+ aliases: ["Immutable"],
+ fields: {
+ name: {
+ validate: (0, _utils.assertNodeType)("JSXIdentifier", "JSXNamespacedName")
+ },
+ value: {
+ optional: true,
+ validate: (0, _utils.assertNodeType)("JSXElement", "JSXFragment", "StringLiteral", "JSXExpressionContainer")
+ }
+ }
+});
+defineType("JSXClosingElement", {
+ visitor: ["name"],
+ aliases: ["Immutable"],
+ fields: {
+ name: {
+ validate: (0, _utils.assertNodeType)("JSXIdentifier", "JSXMemberExpression", "JSXNamespacedName")
+ }
+ }
+});
+defineType("JSXElement", {
+ builder: ["openingElement", "closingElement", "children", "selfClosing"],
+ visitor: ["openingElement", "children", "closingElement"],
+ aliases: ["Immutable", "Expression"],
+ fields: {
+ openingElement: {
+ validate: (0, _utils.assertNodeType)("JSXOpeningElement")
+ },
+ closingElement: {
+ optional: true,
+ validate: (0, _utils.assertNodeType)("JSXClosingElement")
+ },
+ children: {
+ validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("JSXText", "JSXExpressionContainer", "JSXSpreadChild", "JSXElement", "JSXFragment")))
+ },
+ selfClosing: {
+ validate: (0, _utils.assertValueType)("boolean"),
+ optional: true
+ }
+ }
+});
+defineType("JSXEmptyExpression", {});
+defineType("JSXExpressionContainer", {
+ visitor: ["expression"],
+ aliases: ["Immutable"],
+ fields: {
+ expression: {
+ validate: (0, _utils.assertNodeType)("Expression", "JSXEmptyExpression")
+ }
+ }
+});
+defineType("JSXSpreadChild", {
+ visitor: ["expression"],
+ aliases: ["Immutable"],
+ fields: {
+ expression: {
+ validate: (0, _utils.assertNodeType)("Expression")
+ }
+ }
+});
+defineType("JSXIdentifier", {
+ builder: ["name"],
+ fields: {
+ name: {
+ validate: (0, _utils.assertValueType)("string")
+ }
+ }
+});
+defineType("JSXMemberExpression", {
+ visitor: ["object", "property"],
+ fields: {
+ object: {
+ validate: (0, _utils.assertNodeType)("JSXMemberExpression", "JSXIdentifier")
+ },
+ property: {
+ validate: (0, _utils.assertNodeType)("JSXIdentifier")
+ }
+ }
+});
+defineType("JSXNamespacedName", {
+ visitor: ["namespace", "name"],
+ fields: {
+ namespace: {
+ validate: (0, _utils.assertNodeType)("JSXIdentifier")
+ },
+ name: {
+ validate: (0, _utils.assertNodeType)("JSXIdentifier")
+ }
+ }
+});
+defineType("JSXOpeningElement", {
+ builder: ["name", "attributes", "selfClosing"],
+ visitor: ["name", "attributes"],
+ aliases: ["Immutable"],
+ fields: {
+ name: {
+ validate: (0, _utils.assertNodeType)("JSXIdentifier", "JSXMemberExpression", "JSXNamespacedName")
+ },
+ selfClosing: {
+ default: false
+ },
+ attributes: {
+ validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("JSXAttribute", "JSXSpreadAttribute")))
+ },
+ typeParameters: {
+ validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
+ optional: true
+ }
+ }
+});
+defineType("JSXSpreadAttribute", {
+ visitor: ["argument"],
+ fields: {
+ argument: {
+ validate: (0, _utils.assertNodeType)("Expression")
+ }
+ }
+});
+defineType("JSXText", {
+ aliases: ["Immutable"],
+ builder: ["value"],
+ fields: {
+ value: {
+ validate: (0, _utils.assertValueType)("string")
+ }
+ }
+});
+defineType("JSXFragment", {
+ builder: ["openingFragment", "closingFragment", "children"],
+ visitor: ["openingFragment", "children", "closingFragment"],
+ aliases: ["Immutable", "Expression"],
+ fields: {
+ openingFragment: {
+ validate: (0, _utils.assertNodeType)("JSXOpeningFragment")
+ },
+ closingFragment: {
+ validate: (0, _utils.assertNodeType)("JSXClosingFragment")
+ },
+ children: {
+ validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("JSXText", "JSXExpressionContainer", "JSXSpreadChild", "JSXElement", "JSXFragment")))
+ }
+ }
+});
+defineType("JSXOpeningFragment", {
+ aliases: ["Immutable"]
+});
+defineType("JSXClosingFragment", {
+ aliases: ["Immutable"]
+});
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/definitions/misc.js b/node_modules/@babel/types/lib/definitions/misc.js
new file mode 100644
index 000000000..07898bdaf
--- /dev/null
+++ b/node_modules/@babel/types/lib/definitions/misc.js
@@ -0,0 +1,32 @@
+"use strict";
+
+var _utils = require("./utils");
+
+var _placeholders = require("./placeholders");
+
+const defineType = (0, _utils.defineAliasedType)("Miscellaneous");
+{
+ defineType("Noop", {
+ visitor: []
+ });
+}
+defineType("Placeholder", {
+ visitor: [],
+ builder: ["expectedNode", "name"],
+ fields: {
+ name: {
+ validate: (0, _utils.assertNodeType)("Identifier")
+ },
+ expectedNode: {
+ validate: (0, _utils.assertOneOf)(..._placeholders.PLACEHOLDERS)
+ }
+ }
+});
+defineType("V8IntrinsicIdentifier", {
+ builder: ["name"],
+ fields: {
+ name: {
+ validate: (0, _utils.assertValueType)("string")
+ }
+ }
+});
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/definitions/placeholders.js b/node_modules/@babel/types/lib/definitions/placeholders.js
new file mode 100644
index 000000000..7277239ae
--- /dev/null
+++ b/node_modules/@babel/types/lib/definitions/placeholders.js
@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.PLACEHOLDERS_FLIPPED_ALIAS = exports.PLACEHOLDERS_ALIAS = exports.PLACEHOLDERS = void 0;
+
+var _utils = require("./utils");
+
+const PLACEHOLDERS = ["Identifier", "StringLiteral", "Expression", "Statement", "Declaration", "BlockStatement", "ClassBody", "Pattern"];
+exports.PLACEHOLDERS = PLACEHOLDERS;
+const PLACEHOLDERS_ALIAS = {
+ Declaration: ["Statement"],
+ Pattern: ["PatternLike", "LVal"]
+};
+exports.PLACEHOLDERS_ALIAS = PLACEHOLDERS_ALIAS;
+
+for (const type of PLACEHOLDERS) {
+ const alias = _utils.ALIAS_KEYS[type];
+ if (alias != null && alias.length) PLACEHOLDERS_ALIAS[type] = alias;
+}
+
+const PLACEHOLDERS_FLIPPED_ALIAS = {};
+exports.PLACEHOLDERS_FLIPPED_ALIAS = PLACEHOLDERS_FLIPPED_ALIAS;
+Object.keys(PLACEHOLDERS_ALIAS).forEach(type => {
+ PLACEHOLDERS_ALIAS[type].forEach(alias => {
+ if (!Object.hasOwnProperty.call(PLACEHOLDERS_FLIPPED_ALIAS, alias)) {
+ PLACEHOLDERS_FLIPPED_ALIAS[alias] = [];
+ }
+
+ PLACEHOLDERS_FLIPPED_ALIAS[alias].push(type);
+ });
+});
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/definitions/typescript.js b/node_modules/@babel/types/lib/definitions/typescript.js
new file mode 100644
index 000000000..3f4382a69
--- /dev/null
+++ b/node_modules/@babel/types/lib/definitions/typescript.js
@@ -0,0 +1,470 @@
+"use strict";
+
+var _utils = require("./utils");
+
+var _core = require("./core");
+
+var _is = require("../validators/is");
+
+const defineType = (0, _utils.defineAliasedType)("TypeScript");
+const bool = (0, _utils.assertValueType)("boolean");
+const tSFunctionTypeAnnotationCommon = {
+ returnType: {
+ validate: (0, _utils.assertNodeType)("TSTypeAnnotation", "Noop"),
+ optional: true
+ },
+ typeParameters: {
+ validate: (0, _utils.assertNodeType)("TSTypeParameterDeclaration", "Noop"),
+ optional: true
+ }
+};
+defineType("TSParameterProperty", {
+ aliases: ["LVal"],
+ visitor: ["parameter"],
+ fields: {
+ accessibility: {
+ validate: (0, _utils.assertOneOf)("public", "private", "protected"),
+ optional: true
+ },
+ readonly: {
+ validate: (0, _utils.assertValueType)("boolean"),
+ optional: true
+ },
+ parameter: {
+ validate: (0, _utils.assertNodeType)("Identifier", "AssignmentPattern")
+ },
+ override: {
+ validate: (0, _utils.assertValueType)("boolean"),
+ optional: true
+ },
+ decorators: {
+ validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
+ optional: true
+ }
+ }
+});
+defineType("TSDeclareFunction", {
+ aliases: ["Statement", "Declaration"],
+ visitor: ["id", "typeParameters", "params", "returnType"],
+ fields: Object.assign({}, _core.functionDeclarationCommon, tSFunctionTypeAnnotationCommon)
+});
+defineType("TSDeclareMethod", {
+ visitor: ["decorators", "key", "typeParameters", "params", "returnType"],
+ fields: Object.assign({}, _core.classMethodOrDeclareMethodCommon, tSFunctionTypeAnnotationCommon)
+});
+defineType("TSQualifiedName", {
+ aliases: ["TSEntityName"],
+ visitor: ["left", "right"],
+ fields: {
+ left: (0, _utils.validateType)("TSEntityName"),
+ right: (0, _utils.validateType)("Identifier")
+ }
+});
+const signatureDeclarationCommon = {
+ typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterDeclaration"),
+ ["parameters"]: (0, _utils.validateArrayOfType)(["Identifier", "RestElement"]),
+ ["typeAnnotation"]: (0, _utils.validateOptionalType)("TSTypeAnnotation")
+};
+const callConstructSignatureDeclaration = {
+ aliases: ["TSTypeElement"],
+ visitor: ["typeParameters", "parameters", "typeAnnotation"],
+ fields: signatureDeclarationCommon
+};
+defineType("TSCallSignatureDeclaration", callConstructSignatureDeclaration);
+defineType("TSConstructSignatureDeclaration", callConstructSignatureDeclaration);
+const namedTypeElementCommon = {
+ key: (0, _utils.validateType)("Expression"),
+ computed: (0, _utils.validate)(bool),
+ optional: (0, _utils.validateOptional)(bool)
+};
+defineType("TSPropertySignature", {
+ aliases: ["TSTypeElement"],
+ visitor: ["key", "typeAnnotation", "initializer"],
+ fields: Object.assign({}, namedTypeElementCommon, {
+ readonly: (0, _utils.validateOptional)(bool),
+ typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation"),
+ initializer: (0, _utils.validateOptionalType)("Expression"),
+ kind: {
+ validate: (0, _utils.assertOneOf)("get", "set")
+ }
+ })
+});
+defineType("TSMethodSignature", {
+ aliases: ["TSTypeElement"],
+ visitor: ["key", "typeParameters", "parameters", "typeAnnotation"],
+ fields: Object.assign({}, signatureDeclarationCommon, namedTypeElementCommon, {
+ kind: {
+ validate: (0, _utils.assertOneOf)("method", "get", "set")
+ }
+ })
+});
+defineType("TSIndexSignature", {
+ aliases: ["TSTypeElement"],
+ visitor: ["parameters", "typeAnnotation"],
+ fields: {
+ readonly: (0, _utils.validateOptional)(bool),
+ static: (0, _utils.validateOptional)(bool),
+ parameters: (0, _utils.validateArrayOfType)("Identifier"),
+ typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation")
+ }
+});
+const tsKeywordTypes = ["TSAnyKeyword", "TSBooleanKeyword", "TSBigIntKeyword", "TSIntrinsicKeyword", "TSNeverKeyword", "TSNullKeyword", "TSNumberKeyword", "TSObjectKeyword", "TSStringKeyword", "TSSymbolKeyword", "TSUndefinedKeyword", "TSUnknownKeyword", "TSVoidKeyword"];
+
+for (const type of tsKeywordTypes) {
+ defineType(type, {
+ aliases: ["TSType", "TSBaseType"],
+ visitor: [],
+ fields: {}
+ });
+}
+
+defineType("TSThisType", {
+ aliases: ["TSType", "TSBaseType"],
+ visitor: [],
+ fields: {}
+});
+const fnOrCtrBase = {
+ aliases: ["TSType"],
+ visitor: ["typeParameters", "parameters", "typeAnnotation"]
+};
+defineType("TSFunctionType", Object.assign({}, fnOrCtrBase, {
+ fields: signatureDeclarationCommon
+}));
+defineType("TSConstructorType", Object.assign({}, fnOrCtrBase, {
+ fields: Object.assign({}, signatureDeclarationCommon, {
+ abstract: (0, _utils.validateOptional)(bool)
+ })
+}));
+defineType("TSTypeReference", {
+ aliases: ["TSType"],
+ visitor: ["typeName", "typeParameters"],
+ fields: {
+ typeName: (0, _utils.validateType)("TSEntityName"),
+ typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation")
+ }
+});
+defineType("TSTypePredicate", {
+ aliases: ["TSType"],
+ visitor: ["parameterName", "typeAnnotation"],
+ builder: ["parameterName", "typeAnnotation", "asserts"],
+ fields: {
+ parameterName: (0, _utils.validateType)(["Identifier", "TSThisType"]),
+ typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation"),
+ asserts: (0, _utils.validateOptional)(bool)
+ }
+});
+defineType("TSTypeQuery", {
+ aliases: ["TSType"],
+ visitor: ["exprName"],
+ fields: {
+ exprName: (0, _utils.validateType)(["TSEntityName", "TSImportType"])
+ }
+});
+defineType("TSTypeLiteral", {
+ aliases: ["TSType"],
+ visitor: ["members"],
+ fields: {
+ members: (0, _utils.validateArrayOfType)("TSTypeElement")
+ }
+});
+defineType("TSArrayType", {
+ aliases: ["TSType"],
+ visitor: ["elementType"],
+ fields: {
+ elementType: (0, _utils.validateType)("TSType")
+ }
+});
+defineType("TSTupleType", {
+ aliases: ["TSType"],
+ visitor: ["elementTypes"],
+ fields: {
+ elementTypes: (0, _utils.validateArrayOfType)(["TSType", "TSNamedTupleMember"])
+ }
+});
+defineType("TSOptionalType", {
+ aliases: ["TSType"],
+ visitor: ["typeAnnotation"],
+ fields: {
+ typeAnnotation: (0, _utils.validateType)("TSType")
+ }
+});
+defineType("TSRestType", {
+ aliases: ["TSType"],
+ visitor: ["typeAnnotation"],
+ fields: {
+ typeAnnotation: (0, _utils.validateType)("TSType")
+ }
+});
+defineType("TSNamedTupleMember", {
+ visitor: ["label", "elementType"],
+ builder: ["label", "elementType", "optional"],
+ fields: {
+ label: (0, _utils.validateType)("Identifier"),
+ optional: {
+ validate: bool,
+ default: false
+ },
+ elementType: (0, _utils.validateType)("TSType")
+ }
+});
+const unionOrIntersection = {
+ aliases: ["TSType"],
+ visitor: ["types"],
+ fields: {
+ types: (0, _utils.validateArrayOfType)("TSType")
+ }
+};
+defineType("TSUnionType", unionOrIntersection);
+defineType("TSIntersectionType", unionOrIntersection);
+defineType("TSConditionalType", {
+ aliases: ["TSType"],
+ visitor: ["checkType", "extendsType", "trueType", "falseType"],
+ fields: {
+ checkType: (0, _utils.validateType)("TSType"),
+ extendsType: (0, _utils.validateType)("TSType"),
+ trueType: (0, _utils.validateType)("TSType"),
+ falseType: (0, _utils.validateType)("TSType")
+ }
+});
+defineType("TSInferType", {
+ aliases: ["TSType"],
+ visitor: ["typeParameter"],
+ fields: {
+ typeParameter: (0, _utils.validateType)("TSTypeParameter")
+ }
+});
+defineType("TSParenthesizedType", {
+ aliases: ["TSType"],
+ visitor: ["typeAnnotation"],
+ fields: {
+ typeAnnotation: (0, _utils.validateType)("TSType")
+ }
+});
+defineType("TSTypeOperator", {
+ aliases: ["TSType"],
+ visitor: ["typeAnnotation"],
+ fields: {
+ operator: (0, _utils.validate)((0, _utils.assertValueType)("string")),
+ typeAnnotation: (0, _utils.validateType)("TSType")
+ }
+});
+defineType("TSIndexedAccessType", {
+ aliases: ["TSType"],
+ visitor: ["objectType", "indexType"],
+ fields: {
+ objectType: (0, _utils.validateType)("TSType"),
+ indexType: (0, _utils.validateType)("TSType")
+ }
+});
+defineType("TSMappedType", {
+ aliases: ["TSType"],
+ visitor: ["typeParameter", "typeAnnotation", "nameType"],
+ fields: {
+ readonly: (0, _utils.validateOptional)(bool),
+ typeParameter: (0, _utils.validateType)("TSTypeParameter"),
+ optional: (0, _utils.validateOptional)(bool),
+ typeAnnotation: (0, _utils.validateOptionalType)("TSType"),
+ nameType: (0, _utils.validateOptionalType)("TSType")
+ }
+});
+defineType("TSLiteralType", {
+ aliases: ["TSType", "TSBaseType"],
+ visitor: ["literal"],
+ fields: {
+ literal: {
+ validate: function () {
+ const unaryExpression = (0, _utils.assertNodeType)("NumericLiteral", "BigIntLiteral");
+ const unaryOperator = (0, _utils.assertOneOf)("-");
+ const literal = (0, _utils.assertNodeType)("NumericLiteral", "StringLiteral", "BooleanLiteral", "BigIntLiteral");
+
+ function validator(parent, key, node) {
+ if ((0, _is.default)("UnaryExpression", node)) {
+ unaryOperator(node, "operator", node.operator);
+ unaryExpression(node, "argument", node.argument);
+ } else {
+ literal(parent, key, node);
+ }
+ }
+
+ validator.oneOfNodeTypes = ["NumericLiteral", "StringLiteral", "BooleanLiteral", "BigIntLiteral", "UnaryExpression"];
+ return validator;
+ }()
+ }
+ }
+});
+defineType("TSExpressionWithTypeArguments", {
+ aliases: ["TSType"],
+ visitor: ["expression", "typeParameters"],
+ fields: {
+ expression: (0, _utils.validateType)("TSEntityName"),
+ typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation")
+ }
+});
+defineType("TSInterfaceDeclaration", {
+ aliases: ["Statement", "Declaration"],
+ visitor: ["id", "typeParameters", "extends", "body"],
+ fields: {
+ declare: (0, _utils.validateOptional)(bool),
+ id: (0, _utils.validateType)("Identifier"),
+ typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterDeclaration"),
+ extends: (0, _utils.validateOptional)((0, _utils.arrayOfType)("TSExpressionWithTypeArguments")),
+ body: (0, _utils.validateType)("TSInterfaceBody")
+ }
+});
+defineType("TSInterfaceBody", {
+ visitor: ["body"],
+ fields: {
+ body: (0, _utils.validateArrayOfType)("TSTypeElement")
+ }
+});
+defineType("TSTypeAliasDeclaration", {
+ aliases: ["Statement", "Declaration"],
+ visitor: ["id", "typeParameters", "typeAnnotation"],
+ fields: {
+ declare: (0, _utils.validateOptional)(bool),
+ id: (0, _utils.validateType)("Identifier"),
+ typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterDeclaration"),
+ typeAnnotation: (0, _utils.validateType)("TSType")
+ }
+});
+defineType("TSAsExpression", {
+ aliases: ["Expression"],
+ visitor: ["expression", "typeAnnotation"],
+ fields: {
+ expression: (0, _utils.validateType)("Expression"),
+ typeAnnotation: (0, _utils.validateType)("TSType")
+ }
+});
+defineType("TSTypeAssertion", {
+ aliases: ["Expression"],
+ visitor: ["typeAnnotation", "expression"],
+ fields: {
+ typeAnnotation: (0, _utils.validateType)("TSType"),
+ expression: (0, _utils.validateType)("Expression")
+ }
+});
+defineType("TSEnumDeclaration", {
+ aliases: ["Statement", "Declaration"],
+ visitor: ["id", "members"],
+ fields: {
+ declare: (0, _utils.validateOptional)(bool),
+ const: (0, _utils.validateOptional)(bool),
+ id: (0, _utils.validateType)("Identifier"),
+ members: (0, _utils.validateArrayOfType)("TSEnumMember"),
+ initializer: (0, _utils.validateOptionalType)("Expression")
+ }
+});
+defineType("TSEnumMember", {
+ visitor: ["id", "initializer"],
+ fields: {
+ id: (0, _utils.validateType)(["Identifier", "StringLiteral"]),
+ initializer: (0, _utils.validateOptionalType)("Expression")
+ }
+});
+defineType("TSModuleDeclaration", {
+ aliases: ["Statement", "Declaration"],
+ visitor: ["id", "body"],
+ fields: {
+ declare: (0, _utils.validateOptional)(bool),
+ global: (0, _utils.validateOptional)(bool),
+ id: (0, _utils.validateType)(["Identifier", "StringLiteral"]),
+ body: (0, _utils.validateType)(["TSModuleBlock", "TSModuleDeclaration"])
+ }
+});
+defineType("TSModuleBlock", {
+ aliases: ["Scopable", "Block", "BlockParent"],
+ visitor: ["body"],
+ fields: {
+ body: (0, _utils.validateArrayOfType)("Statement")
+ }
+});
+defineType("TSImportType", {
+ aliases: ["TSType"],
+ visitor: ["argument", "qualifier", "typeParameters"],
+ fields: {
+ argument: (0, _utils.validateType)("StringLiteral"),
+ qualifier: (0, _utils.validateOptionalType)("TSEntityName"),
+ typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation")
+ }
+});
+defineType("TSImportEqualsDeclaration", {
+ aliases: ["Statement"],
+ visitor: ["id", "moduleReference"],
+ fields: {
+ isExport: (0, _utils.validate)(bool),
+ id: (0, _utils.validateType)("Identifier"),
+ moduleReference: (0, _utils.validateType)(["TSEntityName", "TSExternalModuleReference"]),
+ importKind: {
+ validate: (0, _utils.assertOneOf)("type", "value"),
+ optional: true
+ }
+ }
+});
+defineType("TSExternalModuleReference", {
+ visitor: ["expression"],
+ fields: {
+ expression: (0, _utils.validateType)("StringLiteral")
+ }
+});
+defineType("TSNonNullExpression", {
+ aliases: ["Expression"],
+ visitor: ["expression"],
+ fields: {
+ expression: (0, _utils.validateType)("Expression")
+ }
+});
+defineType("TSExportAssignment", {
+ aliases: ["Statement"],
+ visitor: ["expression"],
+ fields: {
+ expression: (0, _utils.validateType)("Expression")
+ }
+});
+defineType("TSNamespaceExportDeclaration", {
+ aliases: ["Statement"],
+ visitor: ["id"],
+ fields: {
+ id: (0, _utils.validateType)("Identifier")
+ }
+});
+defineType("TSTypeAnnotation", {
+ visitor: ["typeAnnotation"],
+ fields: {
+ typeAnnotation: {
+ validate: (0, _utils.assertNodeType)("TSType")
+ }
+ }
+});
+defineType("TSTypeParameterInstantiation", {
+ visitor: ["params"],
+ fields: {
+ params: {
+ validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSType")))
+ }
+ }
+});
+defineType("TSTypeParameterDeclaration", {
+ visitor: ["params"],
+ fields: {
+ params: {
+ validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSTypeParameter")))
+ }
+ }
+});
+defineType("TSTypeParameter", {
+ builder: ["constraint", "default", "name"],
+ visitor: ["constraint", "default"],
+ fields: {
+ name: {
+ validate: (0, _utils.assertValueType)("string")
+ },
+ constraint: {
+ validate: (0, _utils.assertNodeType)("TSType"),
+ optional: true
+ },
+ default: {
+ validate: (0, _utils.assertNodeType)("TSType"),
+ optional: true
+ }
+ }
+});
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/definitions/utils.js b/node_modules/@babel/types/lib/definitions/utils.js
new file mode 100644
index 000000000..70263e5cd
--- /dev/null
+++ b/node_modules/@babel/types/lib/definitions/utils.js
@@ -0,0 +1,343 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.VISITOR_KEYS = exports.NODE_PARENT_VALIDATIONS = exports.NODE_FIELDS = exports.FLIPPED_ALIAS_KEYS = exports.DEPRECATED_KEYS = exports.BUILDER_KEYS = exports.ALIAS_KEYS = void 0;
+exports.arrayOf = arrayOf;
+exports.arrayOfType = arrayOfType;
+exports.assertEach = assertEach;
+exports.assertNodeOrValueType = assertNodeOrValueType;
+exports.assertNodeType = assertNodeType;
+exports.assertOneOf = assertOneOf;
+exports.assertOptionalChainStart = assertOptionalChainStart;
+exports.assertShape = assertShape;
+exports.assertValueType = assertValueType;
+exports.chain = chain;
+exports.default = defineType;
+exports.defineAliasedType = defineAliasedType;
+exports.typeIs = typeIs;
+exports.validate = validate;
+exports.validateArrayOfType = validateArrayOfType;
+exports.validateOptional = validateOptional;
+exports.validateOptionalType = validateOptionalType;
+exports.validateType = validateType;
+
+var _is = require("../validators/is");
+
+var _validate = require("../validators/validate");
+
+const VISITOR_KEYS = {};
+exports.VISITOR_KEYS = VISITOR_KEYS;
+const ALIAS_KEYS = {};
+exports.ALIAS_KEYS = ALIAS_KEYS;
+const FLIPPED_ALIAS_KEYS = {};
+exports.FLIPPED_ALIAS_KEYS = FLIPPED_ALIAS_KEYS;
+const NODE_FIELDS = {};
+exports.NODE_FIELDS = NODE_FIELDS;
+const BUILDER_KEYS = {};
+exports.BUILDER_KEYS = BUILDER_KEYS;
+const DEPRECATED_KEYS = {};
+exports.DEPRECATED_KEYS = DEPRECATED_KEYS;
+const NODE_PARENT_VALIDATIONS = {};
+exports.NODE_PARENT_VALIDATIONS = NODE_PARENT_VALIDATIONS;
+
+function getType(val) {
+ if (Array.isArray(val)) {
+ return "array";
+ } else if (val === null) {
+ return "null";
+ } else {
+ return typeof val;
+ }
+}
+
+function validate(validate) {
+ return {
+ validate
+ };
+}
+
+function typeIs(typeName) {
+ return typeof typeName === "string" ? assertNodeType(typeName) : assertNodeType(...typeName);
+}
+
+function validateType(typeName) {
+ return validate(typeIs(typeName));
+}
+
+function validateOptional(validate) {
+ return {
+ validate,
+ optional: true
+ };
+}
+
+function validateOptionalType(typeName) {
+ return {
+ validate: typeIs(typeName),
+ optional: true
+ };
+}
+
+function arrayOf(elementType) {
+ return chain(assertValueType("array"), assertEach(elementType));
+}
+
+function arrayOfType(typeName) {
+ return arrayOf(typeIs(typeName));
+}
+
+function validateArrayOfType(typeName) {
+ return validate(arrayOfType(typeName));
+}
+
+function assertEach(callback) {
+ function validator(node, key, val) {
+ if (!Array.isArray(val)) return;
+
+ for (let i = 0; i < val.length; i++) {
+ const subkey = `${key}[${i}]`;
+ const v = val[i];
+ callback(node, subkey, v);
+ if (process.env.BABEL_TYPES_8_BREAKING) (0, _validate.validateChild)(node, subkey, v);
+ }
+ }
+
+ validator.each = callback;
+ return validator;
+}
+
+function assertOneOf(...values) {
+ function validate(node, key, val) {
+ if (values.indexOf(val) < 0) {
+ throw new TypeError(`Property ${key} expected value to be one of ${JSON.stringify(values)} but got ${JSON.stringify(val)}`);
+ }
+ }
+
+ validate.oneOf = values;
+ return validate;
+}
+
+function assertNodeType(...types) {
+ function validate(node, key, val) {
+ for (const type of types) {
+ if ((0, _is.default)(type, val)) {
+ (0, _validate.validateChild)(node, key, val);
+ return;
+ }
+ }
+
+ throw new TypeError(`Property ${key} of ${node.type} expected node to be of a type ${JSON.stringify(types)} but instead got ${JSON.stringify(val == null ? void 0 : val.type)}`);
+ }
+
+ validate.oneOfNodeTypes = types;
+ return validate;
+}
+
+function assertNodeOrValueType(...types) {
+ function validate(node, key, val) {
+ for (const type of types) {
+ if (getType(val) === type || (0, _is.default)(type, val)) {
+ (0, _validate.validateChild)(node, key, val);
+ return;
+ }
+ }
+
+ throw new TypeError(`Property ${key} of ${node.type} expected node to be of a type ${JSON.stringify(types)} but instead got ${JSON.stringify(val == null ? void 0 : val.type)}`);
+ }
+
+ validate.oneOfNodeOrValueTypes = types;
+ return validate;
+}
+
+function assertValueType(type) {
+ function validate(node, key, val) {
+ const valid = getType(val) === type;
+
+ if (!valid) {
+ throw new TypeError(`Property ${key} expected type of ${type} but got ${getType(val)}`);
+ }
+ }
+
+ validate.type = type;
+ return validate;
+}
+
+function assertShape(shape) {
+ function validate(node, key, val) {
+ const errors = [];
+
+ for (const property of Object.keys(shape)) {
+ try {
+ (0, _validate.validateField)(node, property, val[property], shape[property]);
+ } catch (error) {
+ if (error instanceof TypeError) {
+ errors.push(error.message);
+ continue;
+ }
+
+ throw error;
+ }
+ }
+
+ if (errors.length) {
+ throw new TypeError(`Property ${key} of ${node.type} expected to have the following:\n${errors.join("\n")}`);
+ }
+ }
+
+ validate.shapeOf = shape;
+ return validate;
+}
+
+function assertOptionalChainStart() {
+ function validate(node) {
+ var _current;
+
+ let current = node;
+
+ while (node) {
+ const {
+ type
+ } = current;
+
+ if (type === "OptionalCallExpression") {
+ if (current.optional) return;
+ current = current.callee;
+ continue;
+ }
+
+ if (type === "OptionalMemberExpression") {
+ if (current.optional) return;
+ current = current.object;
+ continue;
+ }
+
+ break;
+ }
+
+ throw new TypeError(`Non-optional ${node.type} must chain from an optional OptionalMemberExpression or OptionalCallExpression. Found chain from ${(_current = current) == null ? void 0 : _current.type}`);
+ }
+
+ return validate;
+}
+
+function chain(...fns) {
+ function validate(...args) {
+ for (const fn of fns) {
+ fn(...args);
+ }
+ }
+
+ validate.chainOf = fns;
+
+ if (fns.length >= 2 && "type" in fns[0] && fns[0].type === "array" && !("each" in fns[1])) {
+ throw new Error(`An assertValueType("array") validator can only be followed by an assertEach(...) validator.`);
+ }
+
+ return validate;
+}
+
+const validTypeOpts = ["aliases", "builder", "deprecatedAlias", "fields", "inherits", "visitor", "validate"];
+const validFieldKeys = ["default", "optional", "validate"];
+
+function defineAliasedType(...aliases) {
+ return (type, opts = {}) => {
+ let defined = opts.aliases;
+
+ if (!defined) {
+ var _store$opts$inherits$, _defined;
+
+ if (opts.inherits) defined = (_store$opts$inherits$ = store[opts.inherits].aliases) == null ? void 0 : _store$opts$inherits$.slice();
+ (_defined = defined) != null ? _defined : defined = [];
+ opts.aliases = defined;
+ }
+
+ const additional = aliases.filter(a => !defined.includes(a));
+ defined.unshift(...additional);
+ return defineType(type, opts);
+ };
+}
+
+function defineType(type, opts = {}) {
+ const inherits = opts.inherits && store[opts.inherits] || {};
+ let fields = opts.fields;
+
+ if (!fields) {
+ fields = {};
+
+ if (inherits.fields) {
+ const keys = Object.getOwnPropertyNames(inherits.fields);
+
+ for (const key of keys) {
+ const field = inherits.fields[key];
+ const def = field.default;
+
+ if (Array.isArray(def) ? def.length > 0 : def && typeof def === "object") {
+ throw new Error("field defaults can only be primitives or empty arrays currently");
+ }
+
+ fields[key] = {
+ default: Array.isArray(def) ? [] : def,
+ optional: field.optional,
+ validate: field.validate
+ };
+ }
+ }
+ }
+
+ const visitor = opts.visitor || inherits.visitor || [];
+ const aliases = opts.aliases || inherits.aliases || [];
+ const builder = opts.builder || inherits.builder || opts.visitor || [];
+
+ for (const k of Object.keys(opts)) {
+ if (validTypeOpts.indexOf(k) === -1) {
+ throw new Error(`Unknown type option "${k}" on ${type}`);
+ }
+ }
+
+ if (opts.deprecatedAlias) {
+ DEPRECATED_KEYS[opts.deprecatedAlias] = type;
+ }
+
+ for (const key of visitor.concat(builder)) {
+ fields[key] = fields[key] || {};
+ }
+
+ for (const key of Object.keys(fields)) {
+ const field = fields[key];
+
+ if (field.default !== undefined && builder.indexOf(key) === -1) {
+ field.optional = true;
+ }
+
+ if (field.default === undefined) {
+ field.default = null;
+ } else if (!field.validate && field.default != null) {
+ field.validate = assertValueType(getType(field.default));
+ }
+
+ for (const k of Object.keys(field)) {
+ if (validFieldKeys.indexOf(k) === -1) {
+ throw new Error(`Unknown field key "${k}" on ${type}.${key}`);
+ }
+ }
+ }
+
+ VISITOR_KEYS[type] = opts.visitor = visitor;
+ BUILDER_KEYS[type] = opts.builder = builder;
+ NODE_FIELDS[type] = opts.fields = fields;
+ ALIAS_KEYS[type] = opts.aliases = aliases;
+ aliases.forEach(alias => {
+ FLIPPED_ALIAS_KEYS[alias] = FLIPPED_ALIAS_KEYS[alias] || [];
+ FLIPPED_ALIAS_KEYS[alias].push(type);
+ });
+
+ if (opts.validate) {
+ NODE_PARENT_VALIDATIONS[type] = opts.validate;
+ }
+
+ store[type] = opts;
+}
+
+const store = {};
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/index-legacy.d.ts b/node_modules/@babel/types/lib/index-legacy.d.ts
new file mode 100644
index 000000000..9c81afe9f
--- /dev/null
+++ b/node_modules/@babel/types/lib/index-legacy.d.ts
@@ -0,0 +1,2717 @@
+// NOTE: This file is autogenerated. Do not modify.
+// See packages/babel-types/scripts/generators/typescript-legacy.js for script used.
+
+interface BaseComment {
+ value: string;
+ start: number;
+ end: number;
+ loc: SourceLocation;
+ type: "CommentBlock" | "CommentLine";
+}
+
+export interface CommentBlock extends BaseComment {
+ type: "CommentBlock";
+}
+
+export interface CommentLine extends BaseComment {
+ type: "CommentLine";
+}
+
+export type Comment = CommentBlock | CommentLine;
+
+export interface SourceLocation {
+ start: {
+ line: number;
+ column: number;
+ };
+
+ end: {
+ line: number;
+ column: number;
+ };
+}
+
+interface BaseNode {
+ leadingComments: ReadonlyArray | null;
+ innerComments: ReadonlyArray | null;
+ trailingComments: ReadonlyArray | null;
+ start: number | null;
+ end: number | null;
+ loc: SourceLocation | null;
+ type: Node["type"];
+ extra?: Record;
+}
+
+export type Node = Accessor | AnyTypeAnnotation | ArgumentPlaceholder | ArrayExpression | ArrayPattern | ArrayTypeAnnotation | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BigIntLiteral | Binary | BinaryExpression | BindExpression | Block | BlockParent | BlockStatement | BooleanLiteral | BooleanLiteralTypeAnnotation | BooleanTypeAnnotation | BreakStatement | CallExpression | CatchClause | Class | ClassAccessorProperty | ClassBody | ClassDeclaration | ClassExpression | ClassImplements | ClassMethod | ClassPrivateMethod | ClassPrivateProperty | ClassProperty | CompletionStatement | Conditional | ConditionalExpression | ContinueStatement | DebuggerStatement | DecimalLiteral | Declaration | DeclareClass | DeclareExportAllDeclaration | DeclareExportDeclaration | DeclareFunction | DeclareInterface | DeclareModule | DeclareModuleExports | DeclareOpaqueType | DeclareTypeAlias | DeclareVariable | DeclaredPredicate | Decorator | Directive | DirectiveLiteral | DoExpression | DoWhileStatement | EmptyStatement | EmptyTypeAnnotation | EnumBody | EnumBooleanBody | EnumBooleanMember | EnumDeclaration | EnumDefaultedMember | EnumMember | EnumNumberBody | EnumNumberMember | EnumStringBody | EnumStringMember | EnumSymbolBody | ExistsTypeAnnotation | ExportAllDeclaration | ExportDeclaration | ExportDefaultDeclaration | ExportDefaultSpecifier | ExportNamedDeclaration | ExportNamespaceSpecifier | ExportSpecifier | Expression | ExpressionStatement | ExpressionWrapper | File | Flow | FlowBaseAnnotation | FlowDeclaration | FlowPredicate | FlowType | For | ForInStatement | ForOfStatement | ForStatement | ForXStatement | Function | FunctionDeclaration | FunctionExpression | FunctionParent | FunctionTypeAnnotation | FunctionTypeParam | GenericTypeAnnotation | Identifier | IfStatement | Immutable | Import | ImportAttribute | ImportDeclaration | ImportDefaultSpecifier | ImportNamespaceSpecifier | ImportSpecifier | IndexedAccessType | InferredPredicate | InterfaceDeclaration | InterfaceExtends | InterfaceTypeAnnotation | InterpreterDirective | IntersectionTypeAnnotation | JSX | JSXAttribute | JSXClosingElement | JSXClosingFragment | JSXElement | JSXEmptyExpression | JSXExpressionContainer | JSXFragment | JSXIdentifier | JSXMemberExpression | JSXNamespacedName | JSXOpeningElement | JSXOpeningFragment | JSXSpreadAttribute | JSXSpreadChild | JSXText | LVal | LabeledStatement | Literal | LogicalExpression | Loop | MemberExpression | MetaProperty | Method | Miscellaneous | MixedTypeAnnotation | ModuleDeclaration | ModuleExpression | ModuleSpecifier | NewExpression | Noop | NullLiteral | NullLiteralTypeAnnotation | NullableTypeAnnotation | NumberLiteral | NumberLiteralTypeAnnotation | NumberTypeAnnotation | NumericLiteral | ObjectExpression | ObjectMember | ObjectMethod | ObjectPattern | ObjectProperty | ObjectTypeAnnotation | ObjectTypeCallProperty | ObjectTypeIndexer | ObjectTypeInternalSlot | ObjectTypeProperty | ObjectTypeSpreadProperty | OpaqueType | OptionalCallExpression | OptionalIndexedAccessType | OptionalMemberExpression | ParenthesizedExpression | Pattern | PatternLike | PipelineBareFunction | PipelinePrimaryTopicReference | PipelineTopicExpression | Placeholder | Private | PrivateName | Program | Property | Pureish | QualifiedTypeIdentifier | RecordExpression | RegExpLiteral | RegexLiteral | RestElement | RestProperty | ReturnStatement | Scopable | SequenceExpression | SpreadElement | SpreadProperty | Standardized | Statement | StaticBlock | StringLiteral | StringLiteralTypeAnnotation | StringTypeAnnotation | Super | SwitchCase | SwitchStatement | SymbolTypeAnnotation | TSAnyKeyword | TSArrayType | TSAsExpression | TSBaseType | TSBigIntKeyword | TSBooleanKeyword | TSCallSignatureDeclaration | TSConditionalType | TSConstructSignatureDeclaration | TSConstructorType | TSDeclareFunction | TSDeclareMethod | TSEntityName | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSExpressionWithTypeArguments | TSExternalModuleReference | TSFunctionType | TSImportEqualsDeclaration | TSImportType | TSIndexSignature | TSIndexedAccessType | TSInferType | TSInterfaceBody | TSInterfaceDeclaration | TSIntersectionType | TSIntrinsicKeyword | TSLiteralType | TSMappedType | TSMethodSignature | TSModuleBlock | TSModuleDeclaration | TSNamedTupleMember | TSNamespaceExportDeclaration | TSNeverKeyword | TSNonNullExpression | TSNullKeyword | TSNumberKeyword | TSObjectKeyword | TSOptionalType | TSParameterProperty | TSParenthesizedType | TSPropertySignature | TSQualifiedName | TSRestType | TSStringKeyword | TSSymbolKeyword | TSThisType | TSTupleType | TSType | TSTypeAliasDeclaration | TSTypeAnnotation | TSTypeAssertion | TSTypeElement | TSTypeLiteral | TSTypeOperator | TSTypeParameter | TSTypeParameterDeclaration | TSTypeParameterInstantiation | TSTypePredicate | TSTypeQuery | TSTypeReference | TSUndefinedKeyword | TSUnionType | TSUnknownKeyword | TSVoidKeyword | TaggedTemplateExpression | TemplateElement | TemplateLiteral | Terminatorless | ThisExpression | ThisTypeAnnotation | ThrowStatement | TopicReference | TryStatement | TupleExpression | TupleTypeAnnotation | TypeAlias | TypeAnnotation | TypeCastExpression | TypeParameter | TypeParameterDeclaration | TypeParameterInstantiation | TypeScript | TypeofTypeAnnotation | UnaryExpression | UnaryLike | UnionTypeAnnotation | UpdateExpression | UserWhitespacable | V8IntrinsicIdentifier | VariableDeclaration | VariableDeclarator | Variance | VoidTypeAnnotation | While | WhileStatement | WithStatement | YieldExpression;
+
+export interface ArrayExpression extends BaseNode {
+ type: "ArrayExpression";
+ elements: Array;
+}
+
+export interface AssignmentExpression extends BaseNode {
+ type: "AssignmentExpression";
+ operator: string;
+ left: LVal;
+ right: Expression;
+}
+
+export interface BinaryExpression extends BaseNode {
+ type: "BinaryExpression";
+ operator: "+" | "-" | "/" | "%" | "*" | "**" | "&" | "|" | ">>" | ">>>" | "<<" | "^" | "==" | "===" | "!=" | "!==" | "in" | "instanceof" | ">" | "<" | ">=" | "<=";
+ left: Expression | PrivateName;
+ right: Expression;
+}
+
+export interface InterpreterDirective extends BaseNode {
+ type: "InterpreterDirective";
+ value: string;
+}
+
+export interface Directive extends BaseNode {
+ type: "Directive";
+ value: DirectiveLiteral;
+}
+
+export interface DirectiveLiteral extends BaseNode {
+ type: "DirectiveLiteral";
+ value: string;
+}
+
+export interface BlockStatement extends BaseNode {
+ type: "BlockStatement";
+ body: Array;
+ directives: Array;
+}
+
+export interface BreakStatement extends BaseNode {
+ type: "BreakStatement";
+ label: Identifier | null;
+}
+
+export interface CallExpression extends BaseNode {
+ type: "CallExpression";
+ callee: Expression | V8IntrinsicIdentifier;
+ arguments: Array;
+ optional: true | false | null;
+ typeArguments: TypeParameterInstantiation | null;
+ typeParameters: TSTypeParameterInstantiation | null;
+}
+
+export interface CatchClause extends BaseNode {
+ type: "CatchClause";
+ param: Identifier | ArrayPattern | ObjectPattern | null;
+ body: BlockStatement;
+}
+
+export interface ConditionalExpression extends BaseNode {
+ type: "ConditionalExpression";
+ test: Expression;
+ consequent: Expression;
+ alternate: Expression;
+}
+
+export interface ContinueStatement extends BaseNode {
+ type: "ContinueStatement";
+ label: Identifier | null;
+}
+
+export interface DebuggerStatement extends BaseNode {
+ type: "DebuggerStatement";
+}
+
+export interface DoWhileStatement extends BaseNode {
+ type: "DoWhileStatement";
+ test: Expression;
+ body: Statement;
+}
+
+export interface EmptyStatement extends BaseNode {
+ type: "EmptyStatement";
+}
+
+export interface ExpressionStatement extends BaseNode {
+ type: "ExpressionStatement";
+ expression: Expression;
+}
+
+export interface File extends BaseNode {
+ type: "File";
+ program: Program;
+ comments: Array | null;
+ tokens: Array | null;
+}
+
+export interface ForInStatement extends BaseNode {
+ type: "ForInStatement";
+ left: VariableDeclaration | LVal;
+ right: Expression;
+ body: Statement;
+}
+
+export interface ForStatement extends BaseNode {
+ type: "ForStatement";
+ init: VariableDeclaration | Expression | null;
+ test: Expression | null;
+ update: Expression | null;
+ body: Statement;
+}
+
+export interface FunctionDeclaration extends BaseNode {
+ type: "FunctionDeclaration";
+ id: Identifier | null;
+ params: Array;
+ body: BlockStatement;
+ generator: boolean;
+ async: boolean;
+ declare: boolean | null;
+ returnType: TypeAnnotation | TSTypeAnnotation | Noop | null;
+ typeParameters: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null;
+}
+
+export interface FunctionExpression extends BaseNode {
+ type: "FunctionExpression";
+ id: Identifier | null;
+ params: Array;
+ body: BlockStatement;
+ generator: boolean;
+ async: boolean;
+ returnType: TypeAnnotation | TSTypeAnnotation | Noop | null;
+ typeParameters: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null;
+}
+
+export interface Identifier extends BaseNode {
+ type: "Identifier";
+ name: string;
+ decorators: Array | null;
+ optional: boolean | null;
+ typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop | null;
+}
+
+export interface IfStatement extends BaseNode {
+ type: "IfStatement";
+ test: Expression;
+ consequent: Statement;
+ alternate: Statement | null;
+}
+
+export interface LabeledStatement extends BaseNode {
+ type: "LabeledStatement";
+ label: Identifier;
+ body: Statement;
+}
+
+export interface StringLiteral extends BaseNode {
+ type: "StringLiteral";
+ value: string;
+}
+
+export interface NumericLiteral extends BaseNode {
+ type: "NumericLiteral";
+ value: number;
+}
+
+export interface NullLiteral extends BaseNode {
+ type: "NullLiteral";
+}
+
+export interface BooleanLiteral extends BaseNode {
+ type: "BooleanLiteral";
+ value: boolean;
+}
+
+export interface RegExpLiteral extends BaseNode {
+ type: "RegExpLiteral";
+ pattern: string;
+ flags: string;
+}
+
+export interface LogicalExpression extends BaseNode {
+ type: "LogicalExpression";
+ operator: "||" | "&&" | "??";
+ left: Expression;
+ right: Expression;
+}
+
+export interface MemberExpression extends BaseNode {
+ type: "MemberExpression";
+ object: Expression;
+ property: Expression | Identifier | PrivateName;
+ computed: boolean;
+ optional: true | false | null;
+}
+
+export interface NewExpression extends BaseNode {
+ type: "NewExpression";
+ callee: Expression | V8IntrinsicIdentifier;
+ arguments: Array;
+ optional: true | false | null;
+ typeArguments: TypeParameterInstantiation | null;
+ typeParameters: TSTypeParameterInstantiation | null;
+}
+
+export interface Program extends BaseNode {
+ type: "Program";
+ body: Array;
+ directives: Array;
+ sourceType: "script" | "module";
+ interpreter: InterpreterDirective | null;
+ sourceFile: string;
+}
+
+export interface ObjectExpression extends BaseNode {
+ type: "ObjectExpression";
+ properties: Array;
+}
+
+export interface ObjectMethod extends BaseNode {
+ type: "ObjectMethod";
+ kind: "method" | "get" | "set";
+ key: Expression | Identifier | StringLiteral | NumericLiteral;
+ params: Array;
+ body: BlockStatement;
+ computed: boolean;
+ generator: boolean;
+ async: boolean;
+ decorators: Array | null;
+ returnType: TypeAnnotation | TSTypeAnnotation | Noop | null;
+ typeParameters: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null;
+}
+
+export interface ObjectProperty extends BaseNode {
+ type: "ObjectProperty";
+ key: Expression | Identifier | StringLiteral | NumericLiteral;
+ value: Expression | PatternLike;
+ computed: boolean;
+ shorthand: boolean;
+ decorators: Array | null;
+}
+
+export interface RestElement extends BaseNode {
+ type: "RestElement";
+ argument: LVal;
+ decorators: Array | null;
+ optional: boolean | null;
+ typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop | null;
+}
+
+export interface ReturnStatement extends BaseNode {
+ type: "ReturnStatement";
+ argument: Expression | null;
+}
+
+export interface SequenceExpression extends BaseNode {
+ type: "SequenceExpression";
+ expressions: Array;
+}
+
+export interface ParenthesizedExpression extends BaseNode {
+ type: "ParenthesizedExpression";
+ expression: Expression;
+}
+
+export interface SwitchCase extends BaseNode {
+ type: "SwitchCase";
+ test: Expression | null;
+ consequent: Array;
+}
+
+export interface SwitchStatement extends BaseNode {
+ type: "SwitchStatement";
+ discriminant: Expression;
+ cases: Array;
+}
+
+export interface ThisExpression extends BaseNode {
+ type: "ThisExpression";
+}
+
+export interface ThrowStatement extends BaseNode {
+ type: "ThrowStatement";
+ argument: Expression;
+}
+
+export interface TryStatement extends BaseNode {
+ type: "TryStatement";
+ block: BlockStatement;
+ handler: CatchClause | null;
+ finalizer: BlockStatement | null;
+}
+
+export interface UnaryExpression extends BaseNode {
+ type: "UnaryExpression";
+ operator: "void" | "throw" | "delete" | "!" | "+" | "-" | "~" | "typeof";
+ argument: Expression;
+ prefix: boolean;
+}
+
+export interface UpdateExpression extends BaseNode {
+ type: "UpdateExpression";
+ operator: "++" | "--";
+ argument: Expression;
+ prefix: boolean;
+}
+
+export interface VariableDeclaration extends BaseNode {
+ type: "VariableDeclaration";
+ kind: "var" | "let" | "const";
+ declarations: Array;
+ declare: boolean | null;
+}
+
+export interface VariableDeclarator extends BaseNode {
+ type: "VariableDeclarator";
+ id: LVal;
+ init: Expression | null;
+ definite: boolean | null;
+}
+
+export interface WhileStatement extends BaseNode {
+ type: "WhileStatement";
+ test: Expression;
+ body: Statement;
+}
+
+export interface WithStatement extends BaseNode {
+ type: "WithStatement";
+ object: Expression;
+ body: Statement;
+}
+
+export interface AssignmentPattern extends BaseNode {
+ type: "AssignmentPattern";
+ left: Identifier | ObjectPattern | ArrayPattern | MemberExpression;
+ right: Expression;
+ decorators: Array | null;
+ typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop | null;
+}
+
+export interface ArrayPattern extends BaseNode {
+ type: "ArrayPattern";
+ elements: Array;
+ decorators: Array | null;
+ optional: boolean | null;
+ typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop | null;
+}
+
+export interface ArrowFunctionExpression extends BaseNode {
+ type: "ArrowFunctionExpression";
+ params: Array;
+ body: BlockStatement | Expression;
+ async: boolean;
+ expression: boolean;
+ generator: boolean;
+ returnType: TypeAnnotation | TSTypeAnnotation | Noop | null;
+ typeParameters: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null;
+}
+
+export interface ClassBody extends BaseNode {
+ type: "ClassBody";
+ body: Array;
+}
+
+export interface ClassExpression extends BaseNode {
+ type: "ClassExpression";
+ id: Identifier | null;
+ superClass: Expression | null;
+ body: ClassBody;
+ decorators: Array | null;
+ implements: Array | null;
+ mixins: InterfaceExtends | null;
+ superTypeParameters: TypeParameterInstantiation | TSTypeParameterInstantiation | null;
+ typeParameters: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null;
+}
+
+export interface ClassDeclaration extends BaseNode {
+ type: "ClassDeclaration";
+ id: Identifier;
+ superClass: Expression | null;
+ body: ClassBody;
+ decorators: Array | null;
+ abstract: boolean | null;
+ declare: boolean | null;
+ implements: Array | null;
+ mixins: InterfaceExtends | null;
+ superTypeParameters: TypeParameterInstantiation | TSTypeParameterInstantiation | null;
+ typeParameters: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null;
+}
+
+export interface ExportAllDeclaration extends BaseNode {
+ type: "ExportAllDeclaration";
+ source: StringLiteral;
+ assertions: Array | null;
+ exportKind: "type" | "value" | null;
+}
+
+export interface ExportDefaultDeclaration extends BaseNode {
+ type: "ExportDefaultDeclaration";
+ declaration: FunctionDeclaration | TSDeclareFunction | ClassDeclaration | Expression;
+ exportKind: "value" | null;
+}
+
+export interface ExportNamedDeclaration extends BaseNode {
+ type: "ExportNamedDeclaration";
+ declaration: Declaration | null;
+ specifiers: Array;
+ source: StringLiteral | null;
+ assertions: Array | null;
+ exportKind: "type" | "value" | null;
+}
+
+export interface ExportSpecifier extends BaseNode {
+ type: "ExportSpecifier";
+ local: Identifier;
+ exported: Identifier | StringLiteral;
+ exportKind: "type" | "value" | null;
+}
+
+export interface ForOfStatement extends BaseNode {
+ type: "ForOfStatement";
+ left: VariableDeclaration | LVal;
+ right: Expression;
+ body: Statement;
+ await: boolean;
+}
+
+export interface ImportDeclaration extends BaseNode {
+ type: "ImportDeclaration";
+ specifiers: Array;
+ source: StringLiteral;
+ assertions: Array | null;
+ importKind: "type" | "typeof" | "value" | null;
+}
+
+export interface ImportDefaultSpecifier extends BaseNode {
+ type: "ImportDefaultSpecifier";
+ local: Identifier;
+}
+
+export interface ImportNamespaceSpecifier extends BaseNode {
+ type: "ImportNamespaceSpecifier";
+ local: Identifier;
+}
+
+export interface ImportSpecifier extends BaseNode {
+ type: "ImportSpecifier";
+ local: Identifier;
+ imported: Identifier | StringLiteral;
+ importKind: "type" | "typeof" | "value" | null;
+}
+
+export interface MetaProperty extends BaseNode {
+ type: "MetaProperty";
+ meta: Identifier;
+ property: Identifier;
+}
+
+export interface ClassMethod extends BaseNode {
+ type: "ClassMethod";
+ kind: "get" | "set" | "method" | "constructor";
+ key: Identifier | StringLiteral | NumericLiteral | Expression;
+ params: Array;
+ body: BlockStatement;
+ computed: boolean;
+ static: boolean;
+ generator: boolean;
+ async: boolean;
+ abstract: boolean | null;
+ access: "public" | "private" | "protected" | null;
+ accessibility: "public" | "private" | "protected" | null;
+ decorators: Array | null;
+ optional: boolean | null;
+ override: boolean;
+ returnType: TypeAnnotation | TSTypeAnnotation | Noop | null;
+ typeParameters: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null;
+}
+
+export interface ObjectPattern extends BaseNode {
+ type: "ObjectPattern";
+ properties: Array;
+ decorators: Array | null;
+ typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop | null;
+}
+
+export interface SpreadElement extends BaseNode {
+ type: "SpreadElement";
+ argument: Expression;
+}
+
+export interface Super extends BaseNode {
+ type: "Super";
+}
+
+export interface TaggedTemplateExpression extends BaseNode {
+ type: "TaggedTemplateExpression";
+ tag: Expression;
+ quasi: TemplateLiteral;
+ typeParameters: TypeParameterInstantiation | TSTypeParameterInstantiation | null;
+}
+
+export interface TemplateElement extends BaseNode {
+ type: "TemplateElement";
+ value: { raw: string, cooked?: string };
+ tail: boolean;
+}
+
+export interface TemplateLiteral extends BaseNode {
+ type: "TemplateLiteral";
+ quasis: Array;
+ expressions: Array;
+}
+
+export interface YieldExpression extends BaseNode {
+ type: "YieldExpression";
+ argument: Expression | null;
+ delegate: boolean;
+}
+
+export interface AwaitExpression extends BaseNode {
+ type: "AwaitExpression";
+ argument: Expression;
+}
+
+export interface Import extends BaseNode {
+ type: "Import";
+}
+
+export interface BigIntLiteral extends BaseNode {
+ type: "BigIntLiteral";
+ value: string;
+}
+
+export interface ExportNamespaceSpecifier extends BaseNode {
+ type: "ExportNamespaceSpecifier";
+ exported: Identifier;
+}
+
+export interface OptionalMemberExpression extends BaseNode {
+ type: "OptionalMemberExpression";
+ object: Expression;
+ property: Expression | Identifier;
+ computed: boolean;
+ optional: boolean;
+}
+
+export interface OptionalCallExpression extends BaseNode {
+ type: "OptionalCallExpression";
+ callee: Expression;
+ arguments: Array;
+ optional: boolean;
+ typeArguments: TypeParameterInstantiation | null;
+ typeParameters: TSTypeParameterInstantiation | null;
+}
+
+export interface ClassProperty extends BaseNode {
+ type: "ClassProperty";
+ key: Identifier | StringLiteral | NumericLiteral | Expression;
+ value: Expression | null;
+ typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop | null;
+ decorators: Array | null;
+ computed: boolean;
+ static: boolean;
+ abstract: boolean | null;
+ accessibility: "public" | "private" | "protected" | null;
+ declare: boolean | null;
+ definite: boolean | null;
+ optional: boolean | null;
+ override: boolean;
+ readonly: boolean | null;
+ variance: Variance | null;
+}
+
+export interface ClassAccessorProperty extends BaseNode {
+ type: "ClassAccessorProperty";
+ key: Identifier | StringLiteral | NumericLiteral | Expression | PrivateName;
+ value: Expression | null;
+ typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop | null;
+ decorators: Array | null;
+ computed: boolean;
+ static: boolean;
+ abstract: boolean | null;
+ accessibility: "public" | "private" | "protected" | null;
+ declare: boolean | null;
+ definite: boolean | null;
+ optional: boolean | null;
+ override: boolean;
+ readonly: boolean | null;
+ variance: Variance | null;
+}
+
+export interface ClassPrivateProperty extends BaseNode {
+ type: "ClassPrivateProperty";
+ key: PrivateName;
+ value: Expression | null;
+ decorators: Array | null;
+ static: any;
+ definite: boolean | null;
+ readonly: boolean | null;
+ typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop | null;
+ variance: Variance | null;
+}
+
+export interface ClassPrivateMethod extends BaseNode {
+ type: "ClassPrivateMethod";
+ kind: "get" | "set" | "method" | "constructor";
+ key: PrivateName;
+ params: Array;
+ body: BlockStatement;
+ static: boolean;
+ abstract: boolean | null;
+ access: "public" | "private" | "protected" | null;
+ accessibility: "public" | "private" | "protected" | null;
+ async: boolean;
+ computed: boolean;
+ decorators: Array | null;
+ generator: boolean;
+ optional: boolean | null;
+ override: boolean;
+ returnType: TypeAnnotation | TSTypeAnnotation | Noop | null;
+ typeParameters: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null;
+}
+
+export interface PrivateName extends BaseNode {
+ type: "PrivateName";
+ id: Identifier;
+}
+
+export interface StaticBlock extends BaseNode {
+ type: "StaticBlock";
+ body: Array;
+}
+
+export interface AnyTypeAnnotation extends BaseNode {
+ type: "AnyTypeAnnotation";
+}
+
+export interface ArrayTypeAnnotation extends BaseNode {
+ type: "ArrayTypeAnnotation";
+ elementType: FlowType;
+}
+
+export interface BooleanTypeAnnotation extends BaseNode {
+ type: "BooleanTypeAnnotation";
+}
+
+export interface BooleanLiteralTypeAnnotation extends BaseNode {
+ type: "BooleanLiteralTypeAnnotation";
+ value: boolean;
+}
+
+export interface NullLiteralTypeAnnotation extends BaseNode {
+ type: "NullLiteralTypeAnnotation";
+}
+
+export interface ClassImplements extends BaseNode {
+ type: "ClassImplements";
+ id: Identifier;
+ typeParameters: TypeParameterInstantiation | null;
+}
+
+export interface DeclareClass extends BaseNode {
+ type: "DeclareClass";
+ id: Identifier;
+ typeParameters: TypeParameterDeclaration | null;
+ extends: Array | null;
+ body: ObjectTypeAnnotation;
+ implements: Array | null;
+ mixins: Array | null;
+}
+
+export interface DeclareFunction extends BaseNode {
+ type: "DeclareFunction";
+ id: Identifier;
+ predicate: DeclaredPredicate | null;
+}
+
+export interface DeclareInterface extends BaseNode {
+ type: "DeclareInterface";
+ id: Identifier;
+ typeParameters: TypeParameterDeclaration | null;
+ extends: Array | null;
+ body: ObjectTypeAnnotation;
+ implements: Array | null;
+ mixins: Array | null;
+}
+
+export interface DeclareModule extends BaseNode {
+ type: "DeclareModule";
+ id: Identifier | StringLiteral;
+ body: BlockStatement;
+ kind: "CommonJS" | "ES" | null;
+}
+
+export interface DeclareModuleExports extends BaseNode {
+ type: "DeclareModuleExports";
+ typeAnnotation: TypeAnnotation;
+}
+
+export interface DeclareTypeAlias extends BaseNode {
+ type: "DeclareTypeAlias";
+ id: Identifier;
+ typeParameters: TypeParameterDeclaration | null;
+ right: FlowType;
+}
+
+export interface DeclareOpaqueType extends BaseNode {
+ type: "DeclareOpaqueType";
+ id: Identifier;
+ typeParameters: TypeParameterDeclaration | null;
+ supertype: FlowType | null;
+ impltype: FlowType | null;
+}
+
+export interface DeclareVariable extends BaseNode {
+ type: "DeclareVariable";
+ id: Identifier;
+}
+
+export interface DeclareExportDeclaration extends BaseNode {
+ type: "DeclareExportDeclaration";
+ declaration: Flow | null;
+ specifiers: Array | null;
+ source: StringLiteral | null;
+ default: boolean | null;
+}
+
+export interface DeclareExportAllDeclaration extends BaseNode {
+ type: "DeclareExportAllDeclaration";
+ source: StringLiteral;
+ exportKind: "type" | "value" | null;
+}
+
+export interface DeclaredPredicate extends BaseNode {
+ type: "DeclaredPredicate";
+ value: Flow;
+}
+
+export interface ExistsTypeAnnotation extends BaseNode {
+ type: "ExistsTypeAnnotation";
+}
+
+export interface FunctionTypeAnnotation extends BaseNode {
+ type: "FunctionTypeAnnotation";
+ typeParameters: TypeParameterDeclaration | null;
+ params: Array;
+ rest: FunctionTypeParam | null;
+ returnType: FlowType;
+ this: FunctionTypeParam | null;
+}
+
+export interface FunctionTypeParam extends BaseNode {
+ type: "FunctionTypeParam";
+ name: Identifier | null;
+ typeAnnotation: FlowType;
+ optional: boolean | null;
+}
+
+export interface GenericTypeAnnotation extends BaseNode {
+ type: "GenericTypeAnnotation";
+ id: Identifier | QualifiedTypeIdentifier;
+ typeParameters: TypeParameterInstantiation | null;
+}
+
+export interface InferredPredicate extends BaseNode {
+ type: "InferredPredicate";
+}
+
+export interface InterfaceExtends extends BaseNode {
+ type: "InterfaceExtends";
+ id: Identifier | QualifiedTypeIdentifier;
+ typeParameters: TypeParameterInstantiation | null;
+}
+
+export interface InterfaceDeclaration extends BaseNode {
+ type: "InterfaceDeclaration";
+ id: Identifier;
+ typeParameters: TypeParameterDeclaration | null;
+ extends: Array | null;
+ body: ObjectTypeAnnotation;
+ implements: Array | null;
+ mixins: Array | null;
+}
+
+export interface InterfaceTypeAnnotation extends BaseNode {
+ type: "InterfaceTypeAnnotation";
+ extends: Array | null;
+ body: ObjectTypeAnnotation;
+}
+
+export interface IntersectionTypeAnnotation extends BaseNode {
+ type: "IntersectionTypeAnnotation";
+ types: Array;
+}
+
+export interface MixedTypeAnnotation extends BaseNode {
+ type: "MixedTypeAnnotation";
+}
+
+export interface EmptyTypeAnnotation extends BaseNode {
+ type: "EmptyTypeAnnotation";
+}
+
+export interface NullableTypeAnnotation extends BaseNode {
+ type: "NullableTypeAnnotation";
+ typeAnnotation: FlowType;
+}
+
+export interface NumberLiteralTypeAnnotation extends BaseNode {
+ type: "NumberLiteralTypeAnnotation";
+ value: number;
+}
+
+export interface NumberTypeAnnotation extends BaseNode {
+ type: "NumberTypeAnnotation";
+}
+
+export interface ObjectTypeAnnotation extends BaseNode {
+ type: "ObjectTypeAnnotation";
+ properties: Array;
+ indexers: Array | null;
+ callProperties: Array | null;
+ internalSlots: Array | null;
+ exact: boolean;
+ inexact: boolean | null;
+}
+
+export interface ObjectTypeInternalSlot extends BaseNode {
+ type: "ObjectTypeInternalSlot";
+ id: Identifier;
+ value: FlowType;
+ optional: boolean;
+ static: boolean;
+ method: boolean;
+}
+
+export interface ObjectTypeCallProperty extends BaseNode {
+ type: "ObjectTypeCallProperty";
+ value: FlowType;
+ static: boolean;
+}
+
+export interface ObjectTypeIndexer extends BaseNode {
+ type: "ObjectTypeIndexer";
+ id: Identifier | null;
+ key: FlowType;
+ value: FlowType;
+ variance: Variance | null;
+ static: boolean;
+}
+
+export interface ObjectTypeProperty extends BaseNode {
+ type: "ObjectTypeProperty";
+ key: Identifier | StringLiteral;
+ value: FlowType;
+ variance: Variance | null;
+ kind: "init" | "get" | "set";
+ method: boolean;
+ optional: boolean;
+ proto: boolean;
+ static: boolean;
+}
+
+export interface ObjectTypeSpreadProperty extends BaseNode {
+ type: "ObjectTypeSpreadProperty";
+ argument: FlowType;
+}
+
+export interface OpaqueType extends BaseNode {
+ type: "OpaqueType";
+ id: Identifier;
+ typeParameters: TypeParameterDeclaration | null;
+ supertype: FlowType | null;
+ impltype: FlowType;
+}
+
+export interface QualifiedTypeIdentifier extends BaseNode {
+ type: "QualifiedTypeIdentifier";
+ id: Identifier;
+ qualification: Identifier | QualifiedTypeIdentifier;
+}
+
+export interface StringLiteralTypeAnnotation extends BaseNode {
+ type: "StringLiteralTypeAnnotation";
+ value: string;
+}
+
+export interface StringTypeAnnotation extends BaseNode {
+ type: "StringTypeAnnotation";
+}
+
+export interface SymbolTypeAnnotation extends BaseNode {
+ type: "SymbolTypeAnnotation";
+}
+
+export interface ThisTypeAnnotation extends BaseNode {
+ type: "ThisTypeAnnotation";
+}
+
+export interface TupleTypeAnnotation extends BaseNode {
+ type: "TupleTypeAnnotation";
+ types: Array;
+}
+
+export interface TypeofTypeAnnotation extends BaseNode {
+ type: "TypeofTypeAnnotation";
+ argument: FlowType;
+}
+
+export interface TypeAlias extends BaseNode {
+ type: "TypeAlias";
+ id: Identifier;
+ typeParameters: TypeParameterDeclaration | null;
+ right: FlowType;
+}
+
+export interface TypeAnnotation extends BaseNode {
+ type: "TypeAnnotation";
+ typeAnnotation: FlowType;
+}
+
+export interface TypeCastExpression extends BaseNode {
+ type: "TypeCastExpression";
+ expression: Expression;
+ typeAnnotation: TypeAnnotation;
+}
+
+export interface TypeParameter extends BaseNode {
+ type: "TypeParameter";
+ bound: TypeAnnotation | null;
+ default: FlowType | null;
+ variance: Variance | null;
+ name: string;
+}
+
+export interface TypeParameterDeclaration extends BaseNode {
+ type: "TypeParameterDeclaration";
+ params: Array;
+}
+
+export interface TypeParameterInstantiation extends BaseNode {
+ type: "TypeParameterInstantiation";
+ params: Array;
+}
+
+export interface UnionTypeAnnotation extends BaseNode {
+ type: "UnionTypeAnnotation";
+ types: Array;
+}
+
+export interface Variance extends BaseNode {
+ type: "Variance";
+ kind: "minus" | "plus";
+}
+
+export interface VoidTypeAnnotation extends BaseNode {
+ type: "VoidTypeAnnotation";
+}
+
+export interface EnumDeclaration extends BaseNode {
+ type: "EnumDeclaration";
+ id: Identifier;
+ body: EnumBooleanBody | EnumNumberBody | EnumStringBody | EnumSymbolBody;
+}
+
+export interface EnumBooleanBody extends BaseNode {
+ type: "EnumBooleanBody";
+ members: Array;
+ explicitType: boolean;
+ hasUnknownMembers: boolean;
+}
+
+export interface EnumNumberBody extends BaseNode {
+ type: "EnumNumberBody";
+ members: Array;
+ explicitType: boolean;
+ hasUnknownMembers: boolean;
+}
+
+export interface EnumStringBody extends BaseNode {
+ type: "EnumStringBody";
+ members: Array;
+ explicitType: boolean;
+ hasUnknownMembers: boolean;
+}
+
+export interface EnumSymbolBody extends BaseNode {
+ type: "EnumSymbolBody";
+ members: Array;
+ hasUnknownMembers: boolean;
+}
+
+export interface EnumBooleanMember extends BaseNode {
+ type: "EnumBooleanMember";
+ id: Identifier;
+ init: BooleanLiteral;
+}
+
+export interface EnumNumberMember extends BaseNode {
+ type: "EnumNumberMember";
+ id: Identifier;
+ init: NumericLiteral;
+}
+
+export interface EnumStringMember extends BaseNode {
+ type: "EnumStringMember";
+ id: Identifier;
+ init: StringLiteral;
+}
+
+export interface EnumDefaultedMember extends BaseNode {
+ type: "EnumDefaultedMember";
+ id: Identifier;
+}
+
+export interface IndexedAccessType extends BaseNode {
+ type: "IndexedAccessType";
+ objectType: FlowType;
+ indexType: FlowType;
+}
+
+export interface OptionalIndexedAccessType extends BaseNode {
+ type: "OptionalIndexedAccessType";
+ objectType: FlowType;
+ indexType: FlowType;
+ optional: boolean;
+}
+
+export interface JSXAttribute extends BaseNode {
+ type: "JSXAttribute";
+ name: JSXIdentifier | JSXNamespacedName;
+ value: JSXElement | JSXFragment | StringLiteral | JSXExpressionContainer | null;
+}
+
+export interface JSXClosingElement extends BaseNode {
+ type: "JSXClosingElement";
+ name: JSXIdentifier | JSXMemberExpression | JSXNamespacedName;
+}
+
+export interface JSXElement extends BaseNode {
+ type: "JSXElement";
+ openingElement: JSXOpeningElement;
+ closingElement: JSXClosingElement | null;
+ children: Array;
+ selfClosing: boolean | null;
+}
+
+export interface JSXEmptyExpression extends BaseNode {
+ type: "JSXEmptyExpression";
+}
+
+export interface JSXExpressionContainer extends BaseNode {
+ type: "JSXExpressionContainer";
+ expression: Expression | JSXEmptyExpression;
+}
+
+export interface JSXSpreadChild extends BaseNode {
+ type: "JSXSpreadChild";
+ expression: Expression;
+}
+
+export interface JSXIdentifier extends BaseNode {
+ type: "JSXIdentifier";
+ name: string;
+}
+
+export interface JSXMemberExpression extends BaseNode {
+ type: "JSXMemberExpression";
+ object: JSXMemberExpression | JSXIdentifier;
+ property: JSXIdentifier;
+}
+
+export interface JSXNamespacedName extends BaseNode {
+ type: "JSXNamespacedName";
+ namespace: JSXIdentifier;
+ name: JSXIdentifier;
+}
+
+export interface JSXOpeningElement extends BaseNode {
+ type: "JSXOpeningElement";
+ name: JSXIdentifier | JSXMemberExpression | JSXNamespacedName;
+ attributes: Array;
+ selfClosing: boolean;
+ typeParameters: TypeParameterInstantiation | TSTypeParameterInstantiation | null;
+}
+
+export interface JSXSpreadAttribute extends BaseNode {
+ type: "JSXSpreadAttribute";
+ argument: Expression;
+}
+
+export interface JSXText extends BaseNode {
+ type: "JSXText";
+ value: string;
+}
+
+export interface JSXFragment extends BaseNode {
+ type: "JSXFragment";
+ openingFragment: JSXOpeningFragment;
+ closingFragment: JSXClosingFragment;
+ children: Array