ヤミRoot VoidGate

Viewing: parser.tar

CHANGELOG.md����������������������������������������������������������������������������������������0000644�����������������00000112536�15120211212�0006350 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������# Changelog

> **Tags:**
> - :boom:       [Breaking Change]
> - :eyeglasses: [Spec Compliance]
> - :rocket:     [New Feature]
> - :bug:        [Bug Fix]
> - :memo:       [Documentation]
> - :house:      [Internal]
> - :nail_care:  [Polish]

> Semver Policy: https://github.com/babel/babel/tree/main/packages/babel-parser#semver

_Note: Gaps between patch versions are faulty, broken or test releases._

See the [Babel Changelog](https://github.com/babel/babel/blob/main/CHANGELOG.md) for the pre-6.8.0 version Changelog.

## 6.17.1 (2017-05-10)

### :bug: Bug Fix
 * Fix typo in flow spread operator error (Brian Ng)
 * Fixed invalid number literal parsing ([#473](https://github.com/babel/babylon/pull/473)) (Alex Kuzmenko)
 * Fix number parser ([#433](https://github.com/babel/babylon/pull/433)) (Alex Kuzmenko)
 * Ensure non pattern shorthand props are checked for reserved words ([#479](https://github.com/babel/babylon/pull/479)) (Brian Ng)
 * Remove jsx context when parsing arrow functions ([#475](https://github.com/babel/babylon/pull/475)) (Brian Ng)
 * Allow super in class properties ([#499](https://github.com/babel/babylon/pull/499)) (Brian Ng)
 * Allow flow class field to be named constructor ([#510](https://github.com/babel/babylon/pull/510)) (Brian Ng)

## 6.17.0 (2017-04-20)

### :bug: Bug Fix
 * Cherry-pick #418 to 6.x ([#476](https://github.com/babel/babylon/pull/476)) (Sebastian McKenzie)
 * Add support for invalid escapes in tagged templates ([#274](https://github.com/babel/babylon/pull/274)) (Kevin Gibbons)
 * Throw error if new.target is used outside of a function ([#402](https://github.com/babel/babylon/pull/402)) (Brian Ng)
 * Fix parsing of class properties ([#351](https://github.com/babel/babylon/pull/351)) (Kevin Gibbons)
 * Fix parsing yield with dynamicImport ([#383](https://github.com/babel/babylon/pull/383)) (Brian Ng)
 * Ensure consistent start args for parseParenItem ([#386](https://github.com/babel/babylon/pull/386)) (Brian Ng)

## 7.0.0-beta.8 (2017-04-04)

### New Feature
* Add support for flow type spread (#418) (Conrad Buck)
* Allow statics in flow interfaces (#427) (Brian Ng)

### Bug Fix
* Fix predicate attachment to match flow parser (#428) (Brian Ng)
* Add extra.raw back to JSXText and JSXAttribute (#344) (Alex Rattray)
* Fix rest parameters with array and objects (#424) (Brian Ng)
* Fix number parser (#433) (Alex Kuzmenko)

### Docs
* Fix CONTRIBUTING.md [skip ci] (#432) (Alex Kuzmenko)

### Internal
* Use babel-register script when running babel smoke tests (#442) (Brian Ng)

## 7.0.0-beta.7 (2017-03-22)

### Spec Compliance
* Remove babylon plugin for template revision since it's stage-4 (#426) (Henry Zhu)

### Bug Fix

* Fix push-pop logic in flow (#405) (Daniel Tschinder)

## 7.0.0-beta.6 (2017-03-21)

### New Feature
* Add support for invalid escapes in tagged templates (#274) (Kevin Gibbons)

### Polish
* Improves error message when super is called outside of constructor (#408) (Arshabh Kumar Agarwal)

### Docs

* [7.0] Moved value field in spec from ObjectMember to ObjectProperty as ObjectMethod's don't have it (#415) [skip ci] (James Browning)

## 7.0.0-beta.5 (2017-03-21)

### Bug Fix
* Throw error if new.target is used outside of a function (#402) (Brian Ng)
* Fix parsing of class properties (#351) (Kevin Gibbons)

### Other
 * Test runner: Detect extra property in 'actual' but not in 'expected'. (#407) (Andy)
 * Optimize travis builds (#419) (Daniel Tschinder)
 * Update codecov to 2.0 (#412) (Daniel Tschinder)
 * Fix spec for ClassMethod: It doesn't have a function, it *is* a function. (#406) [skip ci] (Andy)
 * Changed Non-existent RestPattern to RestElement which is what is actually parsed (#409) [skip ci] (James Browning)
 * Upgrade flow to 0.41 (Daniel Tschinder)
 * Fix watch command (#403) (Brian Ng)
 * Update yarn lock (Daniel Tschinder)
 * Fix watch command (#403) (Brian Ng)
 * chore(package): update flow-bin to version 0.41.0 (#395) (greenkeeper[bot])
 * Add estree test for correct order of directives (Daniel Tschinder)
 * Add DoExpression to spec (#364) (Alex Kuzmenko)
 * Mention cloning of repository in CONTRIBUTING.md (#391) [skip ci] (Sumedh Nimkarde)
 * Explain how to run only one test (#389) [skip ci] (Aaron Ang)

 ## 7.0.0-beta.4 (2017-03-01)

* Don't consume async when checking for async func decl (#377) (Brian Ng)
* add `ranges` option [skip ci] (Henry Zhu)
* Don't parse class properties without initializers when classProperties is disabled and Flow is enabled (#300) (Andrew Levine)

## 7.0.0-beta.3 (2017-02-28)

- [7.0] Change RestProperty/SpreadProperty to RestElement/SpreadElement (#384)
- Merge changes from 6.x

## 7.0.0-beta.2 (2017-02-20)

- estree: correctly change literals in all cases (#368) (Daniel Tschinder)

## 7.0.0-beta.1 (2017-02-20)

- Fix negative number literal typeannotations (#366) (Daniel Tschinder)
- Update contributing with more test info [skip ci] (#355) (Brian Ng)

## 7.0.0-beta.0 (2017-02-15)

- Reintroduce Variance node (#333) (Daniel Tschinder)
- Rename NumericLiteralTypeAnnotation to NumberLiteralTypeAnnotation (#332) (Charles Pick)
- [7.0] Remove ForAwaitStatement, add await flag to ForOfStatement (#349) (Brandon Dail)
- chore(package): update ava to version 0.18.0 (#345) (greenkeeper[bot])
- chore(package): update babel-plugin-istanbul to version 4.0.0 (#350) (greenkeeper[bot])
- Change location of ObjectTypeIndexer to match flow (#228) (Daniel Tschinder)
- Rename flow AST Type ExistentialTypeParam to ExistsTypeAnnotation (#322) (Toru Kobayashi)
- Revert "Temporary rollback for erroring on trailing comma with spread (#154)" (#290) (Daniel Tschinder)
- Remove classConstructorCall plugin (#291) (Brian Ng)
- Update yarn.lock (Daniel Tschinder)
- Update cross-env to 3.x (Daniel Tschinder)
- [7.0] Remove node 0.10, 0.12 and 5 from Travis (#284) (Sergey Rubanov)
- Remove `String.fromCodePoint` shim (#279) (Mathias Bynens)

## 6.16.1 (2017-02-23)

### :bug: Regression

- Revert "Fix export default async function to be FunctionDeclaration" ([#375](https://github.com/babel/babylon/pull/375))

Need to modify Babel for this AST node change, so moving to 7.0.

- Revert "Don't parse class properties without initializers when classProperties plugin is disabled, and Flow is enabled" ([#376](https://github.com/babel/babylon/pull/376))

[react-native](https://github.com/facebook/react-native/issues/12542) broke with this so we reverted.

## 6.16.0 (2017-02-23)

### :rocket: New Feature

***ESTree*** compatibility as plugin ([#277](https://github.com/babel/babylon/pull/277)) (Daniel Tschinder)

We finally introduce a new compatibility layer for ESTree. To put babylon into ESTree-compatible mode the new plugin `estree` can be enabled. In this mode the parser will output an AST that is compliant to the specs of [ESTree](https://github.com/estree/estree/)

We highly recommend everyone who uses babylon outside of babel to use this plugin. This will make it much easier for users to switch between different ESTree-compatible parsers. We so far tested several projects with different parsers and exchanged their parser to babylon and in nearly all cases it worked out of the box. Some other estree-compatible parsers include `acorn`, `esprima`, `espree`, `flow-parser`, etc.

To enable `estree` mode simply add the plugin in the config:
```json
{
  "plugins": [ "estree" ]
}
```

If you want to migrate your project from non-ESTree mode to ESTree, have a look at our [Readme](https://github.com/babel/babylon/#output), where all deviations are mentioned.

Add a parseExpression public method ([#213](https://github.com/babel/babylon/pull/213)) (jeromew)

Babylon exports a new function to parse a single expression

```js
import { parseExpression } from 'babylon';

const ast = parseExpression('x || y && z', options);
```

The returned AST will only consist of the expression. The options are the same as for `parse()`

Add startLine option ([#346](https://github.com/babel/babylon/pull/346)) (Raphael Mu)

A new option was added to babylon allowing to change the initial linenumber for the first line which is usually `1`.
Changing this for example to `100` will make line `1` of the input source to be marked as line `100`, line `2` as `101`, line `3` as `102`, ...

Function predicate declaration ([#103](https://github.com/babel/babylon/pull/103)) (Panagiotis Vekris)

Added support for function predicates which flow introduced in version 0.33.0

```js
declare function is_number(x: mixed): boolean %checks(typeof x === "number");
```

Allow imports in declare module ([#315](https://github.com/babel/babylon/pull/315)) (Daniel Tschinder)

Added support for imports within module declarations which flow introduced in version 0.37.0

```js
declare module "C" {
  import type { DT } from "D";
  declare export type CT = { D: DT };
}
```

### :eyeglasses: Spec Compliance

Forbid semicolons after decorators in classes ([#352](https://github.com/babel/babylon/pull/352)) (Kevin Gibbons)

This example now correctly throws an error when there is a semicolon after the decorator:

```js
class A {
@a;
foo(){}
}
```

Keywords are not allowed as local specifier ([#307](https://github.com/babel/babylon/pull/307)) (Daniel Tschinder)

Using keywords in imports is not allowed anymore:

```js
import { default } from "foo";
import { a as debugger } from "foo";
```

Do not allow overwritting of primitive types ([#314](https://github.com/babel/babylon/pull/314)) (Daniel Tschinder)

In flow it is now forbidden to overwrite the primitive types `"any"`, `"mixed"`, `"empty"`, `"bool"`, `"boolean"`, `"number"`, `"string"`, `"void"` and `"null"` with your own type declaration.

Disallow import type { type a } from … ([#305](https://github.com/babel/babylon/pull/305)) (Daniel Tschinder)

The following code now correctly throws an error

```js
import type { type a } from "foo";
```

Don't parse class properties without initializers when classProperties is disabled and Flow is enabled ([#300](https://github.com/babel/babylon/pull/300)) (Andrew Levine)

Ensure that you enable the `classProperties` plugin in order to enable correct parsing of class properties. Prior to this version it was possible to parse them by enabling the `flow` plugin but this was not intended the behaviour.

If you enable the flow plugin you can only define the type of the class properties, but not initialize them.

Fix export default async function to be FunctionDeclaration ([#324](https://github.com/babel/babylon/pull/324)) (Daniel Tschinder)

Parsing the following code now returns a `FunctionDeclaration` AST node instead of `FunctionExpression`.

```js
export default async function bar() {};
```

### :nail_care: Polish

Improve error message on attempt to destructure named import ([#288](https://github.com/babel/babylon/pull/288)) (Brian Ng)

### :bug: Bug Fix

Fix negative number literal typeannotations ([#366](https://github.com/babel/babylon/pull/366)) (Daniel Tschinder)

Ensure takeDecorators is called on exported class ([#358](https://github.com/babel/babylon/pull/358)) (Brian Ng)

ESTree: correctly change literals in all cases ([#368](https://github.com/babel/babylon/pull/368)) (Daniel Tschinder)

Correctly convert RestProperty to Assignable ([#339](https://github.com/babel/babylon/pull/339)) (Daniel Tschinder)

Fix #321 by allowing question marks in type params ([#338](https://github.com/babel/babylon/pull/338)) (Daniel Tschinder)

Fix #336 by correctly setting arrow-param ([#337](https://github.com/babel/babylon/pull/337)) (Daniel Tschinder)

Fix parse error when destructuring `set` with default value ([#317](https://github.com/babel/babylon/pull/317)) (Brian Ng)

Fix ObjectTypeCallProperty static ([#298](https://github.com/babel/babylon/pull/298)) (Dan Harper)


### :house: Internal

Fix generator-method-with-computed-name spec ([#360](https://github.com/babel/babylon/pull/360)) (Alex Rattray)

Fix flow type-parameter-declaration test with unintended semantic ([#361](https://github.com/babel/babylon/pull/361)) (Alex Rattray)

Cleanup and splitup parser functions ([#295](https://github.com/babel/babylon/pull/295)) (Daniel Tschinder)

chore(package): update flow-bin to version 0.38.0 ([#313](https://github.com/babel/babylon/pull/313)) (greenkeeper[bot])

Call inner function instead of 1:1 copy to plugin ([#294](https://github.com/babel/babylon/pull/294)) (Daniel Tschinder)

Update eslint-config-babel to the latest version 🚀 ([#299](https://github.com/babel/babylon/pull/299)) (greenkeeper[bot])

Update eslint-config-babel to the latest version 🚀 ([#293](https://github.com/babel/babylon/pull/293)) (greenkeeper[bot])

devDeps: remove eslint-plugin-babel ([#292](https://github.com/babel/babylon/pull/292)) (Kai Cataldo)

Correct indent eslint rule config ([#276](https://github.com/babel/babylon/pull/276)) (Daniel Tschinder)

Fail tests that have expected.json and throws-option ([#285](https://github.com/babel/babylon/pull/285)) (Daniel Tschinder)

### :memo: Documentation

Update contributing with more test info [skip ci] ([#355](https://github.com/babel/babylon/pull/355)) (Brian Ng)

Update API documentation ([#330](https://github.com/babel/babylon/pull/330)) (Timothy Gu)

Added keywords to package.json ([#323](https://github.com/babel/babylon/pull/323)) (Dmytro)

AST spec: fix casing of `RegExpLiteral` ([#318](https://github.com/babel/babylon/pull/318)) (Mathias Bynens)

## 6.15.0 (2017-01-10)

### :eyeglasses: Spec Compliance

Add support for Flow shorthand import type ([#267](https://github.com/babel/babylon/pull/267)) (Jeff Morrison)

This change implements flows new shorthand import syntax
and where previously you had to write this code:

```js
import {someValue} from "blah";
import type {someType} from "blah";
import typeof {someOtherValue} from "blah";
```

you can now write it like this:

```js
import {
  someValue,
  type someType,
  typeof someOtherValue,
} from "blah";
```

For more information look at [this](https://github.com/facebook/flow/pull/2890) pull request.

flow: allow leading pipes in all positions ([#256](https://github.com/babel/babylon/pull/256)) (Vladimir Kurchatkin)

This change now allows a leading pipe everywhere types can be used:
```js
var f = (x): | 1 | 2 => 1;
```

Throw error when exporting non-declaration ([#241](https://github.com/babel/babylon/pull/241)) (Kai Cataldo)

Previously babylon parsed the following exports, although they are not valid:
```js
export typeof foo;
export new Foo();
export function() {};
export for (;;);
export while(foo);
```

### :bug: Bug Fix

Don't set inType flag when parsing property names ([#266](https://github.com/babel/babylon/pull/266)) (Vladimir Kurchatkin)

This fixes parsing of this case:

```js
const map = {
  [age <= 17] : 'Too young'
};
```

Fix source location for JSXEmptyExpression nodes (fixes #248) ([#249](https://github.com/babel/babylon/pull/249)) (James Long)

The following case produced an invalid AST
```js
<div>{/* foo */}</div>
```

Use fromCodePoint to convert high value unicode entities ([#243](https://github.com/babel/babylon/pull/243)) (Ryan Duffy)

When high value unicode entities (e.g. 💩) were used in the input source code they are now correctly encoded in the resulting AST.

Rename folder to avoid Windows-illegal characters ([#281](https://github.com/babel/babylon/pull/281)) (Ryan Plant)

Allow this.state.clone() when parsing decorators ([#262](https://github.com/babel/babylon/pull/262)) (Alex Rattray)

### :house: Internal

User external-helpers ([#254](https://github.com/babel/babylon/pull/254)) (Daniel Tschinder)

Add watch script for dev ([#234](https://github.com/babel/babylon/pull/234)) (Kai Cataldo)

Freeze current plugins list for "*" option, and remove from README.md ([#245](https://github.com/babel/babylon/pull/245)) (Andrew Levine)

Prepare tests for multiple fixture runners. ([#240](https://github.com/babel/babylon/pull/240)) (Daniel Tschinder)

Add some test coverage for decorators stage-0 plugin ([#250](https://github.com/babel/babylon/pull/250)) (Andrew Levine)

Refactor tokenizer types file ([#263](https://github.com/babel/babylon/pull/263)) (Sven SAULEAU)

Update eslint-config-babel to the latest version 🚀 ([#273](https://github.com/babel/babylon/pull/273)) (greenkeeper[bot])

chore(package): update rollup to version 0.41.0 ([#272](https://github.com/babel/babylon/pull/272)) (greenkeeper[bot])

chore(package): update flow-bin to version 0.37.0 ([#255](https://github.com/babel/babylon/pull/255)) (greenkeeper[bot])

## 6.14.1 (2016-11-17)

### :bug: Bug Fix

Allow `"plugins": ["*"]` ([#229](https://github.com/babel/babylon/pull/229)) (Daniel Tschinder)

```js
{
  "plugins": ["*"]
}
```

Will include all parser plugins instead of specifying each one individually. Useful for tools like babel-eslint, jscodeshift, and ast-explorer.

## 6.14.0 (2016-11-16)

### :eyeglasses: Spec Compliance

Throw error for reserved words `enum` and `await` ([#195](https://github.com/babel/babylon/pull/195)) (Kai Cataldo)

[11.6.2.2 Future Reserved Words](http://www.ecma-international.org/ecma-262/6.0/#sec-future-reserved-words)

Babylon will throw for more reserved words such as `enum` or `await` (in strict mode).

```
class enum {} // throws
class await {} // throws in strict mode (module)
```

Optional names for function types and object type indexers ([#197](https://github.com/babel/babylon/pull/197)) (Gabe Levi)

So where you used to have to write

```js
type A = (x: string, y: boolean) => number;
type B = (z: string) => number;
type C = { [key: string]: number };
```

you can now write (with flow 0.34.0)

```js
type A = (string, boolean) => number;
type B = string => number;
type C = { [string]: number };
```

Parse flow nested array type annotations like `number[][]` ([#219](https://github.com/babel/babylon/pull/219)) (Bernhard Häussner)

Supports these form now of specifying array types:

```js
var a: number[][][][];
var b: string[][];
```

### :bug: Bug Fix

Correctly eat semicolon at the end of `DelcareModuleExports` ([#223](https://github.com/babel/babylon/pull/223))  (Daniel Tschinder)

```
declare module "foo" { declare module.exports: number }
declare module "foo" { declare module.exports: number; }  // also allowed now
```

### :house: Internal

 * Count Babel tests towards Babylon code coverage ([#182](https://github.com/babel/babylon/pull/182)) (Moti Zilberman)
 * Fix strange line endings ([#214](https://github.com/babel/babylon/pull/214)) (Thomas Grainger)
 * Add node 7 (Daniel Tschinder)
 * chore(package): update flow-bin to version 0.34.0 ([#204](https://github.com/babel/babylon/pull/204)) (Greenkeeper)

## v6.13.1 (2016-10-26)

### :nail_care: Polish

- Use rollup for bundling to speed up startup time ([#190](https://github.com/babel/babylon/pull/190)) ([@drewml](https://github.com/DrewML))

```js
const babylon = require('babylon');
const ast = babylon.parse('var foo = "lol";');
```

With that test case, there was a ~95ms savings by removing the need for node to build/traverse the dependency graph.

**Without bundling**
![image](https://cloud.githubusercontent.com/assets/5233399/19420264/3133497e-93ad-11e6-9a6a-2da59c4f5c13.png)

**With bundling**
![image](https://cloud.githubusercontent.com/assets/5233399/19420267/388f556e-93ad-11e6-813e-7c5c396be322.png)

- add clean command [skip ci] ([#201](https://github.com/babel/babylon/pull/201)) (Henry Zhu)
- add ForAwaitStatement (async generator already added) [skip ci] ([#196](https://github.com/babel/babylon/pull/196)) (Henry Zhu)

## v6.13.0 (2016-10-21)

### :eyeglasses: Spec Compliance

Property variance type annotations for Flow plugin ([#161](https://github.com/babel/babylon/pull/161)) (Sam Goldman)

> See https://flowtype.org/docs/variance.html for more information

```js
type T = { +p: T };
interface T { -p: T };
declare class T { +[k:K]: V };
class T { -[k:K]: V };
class C2 { +p: T = e };
```

Raise error on duplicate definition of __proto__ ([#183](https://github.com/babel/babylon/pull/183)) (Moti Zilberman)

```js
({ __proto__: 1, __proto__: 2 }) // Throws an error now
```

### :bug: Bug Fix

Flow: Allow class properties to be named `static` ([#184](https://github.com/babel/babylon/pull/184)) (Moti Zilberman)

```js
declare class A {
  static: T;
}
```

Allow "async" as identifier for object literal property shorthand ([#187](https://github.com/babel/babylon/pull/187)) (Andrew Levine)

```js
var foo = { async, bar };
```

### :nail_care: Polish

Fix flowtype and add inType to state ([#189](https://github.com/babel/babylon/pull/189)) (Daniel Tschinder)

> This improves the performance slightly (because of hidden classes)

### :house: Internal

Fix .gitattributes line ending setting ([#191](https://github.com/babel/babylon/pull/191)) (Moti Zilberman)

Increase test coverage ([#175](https://github.com/babel/babylon/pull/175) (Moti Zilberman)

Readd missin .eslinignore for IDEs (Daniel Tschinder)

Error on missing expected.json fixture in CI ([#188](https://github.com/babel/babylon/pull/188)) (Moti Zilberman)

Add .gitattributes and .editorconfig for LF line endings ([#179](https://github.com/babel/babylon/pull/179)) (Moti Zilberman)

Fixes two tests that are failing after the merge of #172 ([#177](https://github.com/babel/babylon/pull/177)) (Moti Zilberman)

## v6.12.0 (2016-10-14)

### :eyeglasses: Spec Compliance

Implement import() syntax ([#163](https://github.com/babel/babylon/pull/163)) (Jordan Gensler)

#### Dynamic Import

- Proposal Repo: https://github.com/domenic/proposal-dynamic-import
- Championed by [@domenic](https://github.com/domenic)
- stage-2
- [sept-28 tc39 notes](https://github.com/rwaldron/tc39-notes/blob/master/es7/2016-09/sept-28.md#113a-import)

> This repository contains a proposal for adding a "function-like" import() module loading syntactic form to JavaScript

```js
import(`./section-modules/${link.dataset.entryModule}.js`)
.then(module => {
  module.loadPageInto(main);
})
```

Add EmptyTypeAnnotation ([#171](https://github.com/babel/babylon/pull/171)) (Sam Goldman)

#### EmptyTypeAnnotation

Just wasn't covered before.

```js
type T = empty;
```

### :bug: Bug Fix

Fix crash when exporting with destructuring and sparse array ([#170](https://github.com/babel/babylon/pull/170)) (Jeroen Engels)

```js
// was failing due to sparse array
export const { foo: [ ,, qux7 ] } = bar;
```

Allow keyword in Flow object declaration property names with type parameters ([#146](https://github.com/babel/babylon/pull/146)) (Dan Harper)

```js
declare class X {
  foobar<T>(): void;
  static foobar<T>(): void;
}
```

Allow keyword in object/class property names with Flow type parameters ([#145](https://github.com/babel/babylon/pull/145)) (Dan Harper)

```js
class Foo {
  delete<T>(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
<div>
  {...todos.map(todo => <Todo key={todo.id} todo={todo}/>)}
</div>
```

- 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 <a></a>; }` ([#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 `<T>(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 = string> = 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);
}
```
������������������������������������������������������������������������������������������������������������������������������������������������������������������LICENSE���������������������������������������������������������������������������������������������0000644�����������������00000002076�15120211212�0005541 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������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.
������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������README.md�������������������������������������������������������������������������������������������0000644�����������������00000000653�15120211212�0006012 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������# @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
```
�������������������������������������������������������������������������������������bin/babel-parser.js���������������������������������������������������������������������������������0000644�����������������00000000510�15120211212�0010170 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/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, "  "));
}
����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������index.cjs�������������������������������������������������������������������������������������������0000644�����������������00000000157�15120211212�0006342 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������try {
  module.exports = require("./lib/index.cjs");
} catch {
  module.exports = require("./lib/index.js");
}
�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������lib/index.js����������������������������������������������������������������������������������������0000644�����������������00001700303�15120211212�0006746 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������'use strict';

Object.defineProperty(exports, '__esModule', {
  value: true
});
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;
}
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);
}
var ParseErrorCode = {
  SyntaxError: "BABEL_PARSER_SYNTAX_ERROR",
  SourceTypeModuleError: "BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED"
};
const reflect = (keys, last = keys.length - 1) => ({
  get() {
    return keys.reduce((object, key) => object[key], this);
  },
  set(value) {
    keys.reduce((item, key, i) => i === last ? item[key] = value : item[key], this);
  }
});
const instantiate = (constructor, properties, descriptors) => Object.keys(descriptors).map(key => [key, descriptors[key]]).filter(([, descriptor]) => !!descriptor).map(([key, descriptor]) => [key, typeof descriptor === "function" ? {
  value: descriptor,
  enumerable: false
} : typeof descriptor.reflect === "string" ? Object.assign({}, descriptor, reflect(descriptor.reflect.split("."))) : descriptor]).reduce((instance, [key, descriptor]) => Object.defineProperty(instance, key, Object.assign({
  configurable: true
}, descriptor)), Object.assign(new constructor(), properties));
var ModuleErrors = {
  ImportMetaOutsideModule: {
    message: `import.meta may appear only with 'sourceType: "module"'`,
    code: ParseErrorCode.SourceTypeModuleError
  },
  ImportOutsideModule: {
    message: `'import' and 'export' may appear only with 'sourceType: "module"'`,
    code: ParseErrorCode.SourceTypeModuleError
  }
};
const NodeDescriptions = {
  ArrayPattern: "array destructuring pattern",
  AssignmentExpression: "assignment expression",
  AssignmentPattern: "assignment expression",
  ArrowFunctionExpression: "arrow function expression",
  ConditionalExpression: "conditional expression",
  CatchClause: "catch clause",
  ForOfStatement: "for-of statement",
  ForInStatement: "for-in statement",
  ForStatement: "for-loop",
  FormalParameters: "function parameter list",
  Identifier: "identifier",
  ImportSpecifier: "import specifier",
  ImportDefaultSpecifier: "import default specifier",
  ImportNamespaceSpecifier: "import namespace specifier",
  ObjectPattern: "object destructuring pattern",
  ParenthesizedExpression: "parenthesized expression",
  RestElement: "rest element",
  UpdateExpression: {
    true: "prefix operation",
    false: "postfix operation"
  },
  VariableDeclarator: "variable declaration",
  YieldExpression: "yield expression"
};
const toNodeDescription = ({
  type,
  prefix
}) => type === "UpdateExpression" ? NodeDescriptions.UpdateExpression[String(prefix)] : NodeDescriptions[type];
var StandardErrors = {
  AccessorIsGenerator: ({
    kind
  }) => `A ${kind}ter 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.",
  AwaitUsingNotInAsyncContext: "'await using' is only allowed within async functions and at the top levels of modules.",
  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' accessor must not have any formal parameters.",
  BadSetterArity: "A 'set' accessor must have exactly one formal parameter.",
  BadSetterRestParameter: "A 'set' accessor 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: ({
    kind
  }) => `Missing initializer in ${kind} declaration.`,
  DecoratorArgumentsOutsideParentheses: "Decorator arguments must be moved inside parentheses: use '@(decorator(args))' instead of '@(decorator)(args)'.",
  DecoratorBeforeExport: "Decorators must be placed *before* the 'export' keyword. Remove the 'decoratorsBeforeExport: true' option to use the 'export @decorator class {}' syntax.",
  DecoratorsBeforeAfterExport: "Decorators can be placed *either* before or after the 'export' keyword, but not in both locations at the same time.",
  DecoratorConstructor: "Decorators can't be used with a constructor. Did you mean '@dec class { ... }'?",
  DecoratorExportClass: "Decorators must be placed *after* the 'export' keyword. Remove the 'decoratorsBeforeExport: false' option to use the '@decorator export class {}' syntax.",
  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: ({
    exportName
  }) => `\`${exportName}\` 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: ({
    localName,
    exportName
  }) => `A string literal cannot be used as an exported binding without \`from\`.\n- Did you mean \`export { '${localName}' as '${exportName}' } from 'some-module'\`?`,
  ExportDefaultFromAsIdentifier: "'from' is not allowed as an identifier after 'export default'.",
  ForInOfLoopInitializer: ({
    type
  }) => `'${type === "ForInStatement" ? "for-in" : "for-of"}' loop variable declaration may not have an initializer.`,
  ForInUsing: "For-in loop may not start with 'using' declaration.",
  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: ({
    type
  }) => `Unsyntactic ${type === "BreakStatement" ? "break" : "continue"}.`,
  IllegalLanguageModeDirective: "Illegal 'use strict' directive in function with non-simple parameter list.",
  IllegalReturn: "'return' outside of function.",
  ImportAttributesUseAssert: "The `assert` keyword in import attributes is deprecated and it has been replaced by the `with` keyword. You can enable the `deprecatedAssertSyntax: true` option in the import attributes plugin to suppress this error.",
  ImportBindingIsString: ({
    importName
  }) => `A string literal cannot be used as an imported binding.\n- Did you mean \`import { "${importName}" as foo }\`?`,
  ImportCallArgumentTrailingComma: "Trailing comma is disallowed inside import(...) arguments.",
  ImportCallArity: ({
    maxArgumentCount
  }) => `\`import()\` requires exactly ${maxArgumentCount === 1 ? "one argument" : "one or two arguments"}.`,
  ImportCallNotNewExpression: "Cannot use new with import(...).",
  ImportCallSpreadArgument: "`...` is not allowed in `import()`.",
  ImportJSONBindingNotDefault: "A JSON module can only be imported with `default`.",
  ImportReflectionHasAssertion: "`import module x` cannot have assertions.",
  ImportReflectionNotBinding: 'Only `import module x from "./module"` is valid.',
  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: ({
    radix
  }) => `Expected number in radix ${radix}.`,
  InvalidEscapeSequence: "Bad character escape sequence.",
  InvalidEscapeSequenceTemplate: "Invalid escape sequence in template.",
  InvalidEscapedReservedWord: ({
    reservedWord
  }) => `Escape sequence in keyword ${reservedWord}.`,
  InvalidIdentifier: ({
    identifierName
  }) => `Invalid identifier ${identifierName}.`,
  InvalidLhs: ({
    ancestor
  }) => `Invalid left-hand side in ${toNodeDescription(ancestor)}.`,
  InvalidLhsBinding: ({
    ancestor
  }) => `Binding invalid left-hand side in ${toNodeDescription(ancestor)}.`,
  InvalidNumber: "Invalid number.",
  InvalidOrMissingExponent: "Floating-point numbers require a valid exponent after the 'e'.",
  InvalidOrUnexpectedToken: ({
    unexpected
  }) => `Unexpected character '${unexpected}'.`,
  InvalidParenthesizedAssignment: "Invalid parenthesized assignment pattern.",
  InvalidPrivateFieldResolution: ({
    identifierName
  }) => `Private name #${identifierName} 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: ({
    labelName
  }) => `Label '${labelName}' 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.",
  MissingPlugin: ({
    missingPlugin
  }) => `This experimental syntax requires enabling the parser plugin: ${missingPlugin.map(name => JSON.stringify(name)).join(", ")}.`,
  MissingOneOfPlugins: ({
    missingPlugin
  }) => `This experimental syntax requires enabling one of the following parser plugin(s): ${missingPlugin.map(name => JSON.stringify(name)).join(", ")}.`,
  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: ({
    key
  }) => `Duplicate key "${key}" is not allowed in module attributes.`,
  ModuleExportNameHasLoneSurrogate: ({
    surrogateCharCode
  }) => `An export name cannot include a lone surrogate, found '\\u${surrogateCharCode.toString(16)}'.`,
  ModuleExportUndefined: ({
    localName
  }) => `Export '${localName}' 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.",
  PrivateInExpectedIn: ({
    identifierName
  }) => `Private names are only allowed in property accesses (\`obj.#${identifierName}\`) or in \`in\` expressions (\`#${identifierName} in obj\`).`,
  PrivateNameRedeclaration: ({
    identifierName
  }) => `Duplicate private name #${identifierName}.`,
  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 or inside a block.",
  SloppyFunctionAnnexB: "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.",
  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: ({
    keyword
  }) => `Unexpected keyword '${keyword}'.`,
  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: ({
    reservedWord
  }) => `Unexpected reserved word '${reservedWord}'.`,
  UnexpectedSuper: "'super' is only allowed in object methods and classes.",
  UnexpectedToken: ({
    expected,
    unexpected
  }) => `Unexpected token${unexpected ? ` '${unexpected}'.` : ""}${expected ? `, expected "${expected}"` : ""}`,
  UnexpectedTokenUnaryExponentiation: "Illegal expression. Wrap left hand side or entire exponentiation in parentheses.",
  UnexpectedUsingDeclaration: "Using declaration cannot appear in the top level when source type is `script`.",
  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: ({
    target,
    onlyValidPropertyName
  }) => `The only valid meta property for ${target} is ${target}.${onlyValidPropertyName}.`,
  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.",
  UsingDeclarationHasBindingPattern: "Using declaration cannot have destructuring patterns.",
  VarRedeclaration: ({
    identifierName
  }) => `Identifier '${identifierName}' 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."
};
var StrictModeErrors = {
  StrictDelete: "Deleting local variable in strict mode.",
  StrictEvalArguments: ({
    referenceName
  }) => `Assigning to '${referenceName}' in strict mode.`,
  StrictEvalArgumentsBinding: ({
    bindingName
  }) => `Binding '${bindingName}' 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."
};
const UnparenthesizedPipeBodyDescriptions = new Set(["ArrowFunctionExpression", "AssignmentExpression", "ConditionalExpression", "YieldExpression"]);
var PipelineOperatorErrors = {
  PipeBodyIsTighter: "Unexpected yield after pipeline body; any yield 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: ({
    token
  }) => `Invalid topic token ${token}. In order to use ${token} as a topic reference, the pipelineOperator plugin must be configured with { "proposal": "hack", "topicToken": "${token}" }.`,
  PipeTopicUnused: "Hack-style pipe body does not contain a topic reference; Hack-style pipes must use topic at least once.",
  PipeUnparenthesizedBody: ({
    type
  }) => `Hack-style pipe body cannot be an unparenthesized ${toNodeDescription({
    type
  })}; 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.'
};
const _excluded$1 = ["toMessage"],
  _excluded2$1 = ["message"];
function toParseErrorConstructor(_ref) {
  let {
      toMessage
    } = _ref,
    properties = _objectWithoutPropertiesLoose(_ref, _excluded$1);
  return function constructor({
    loc,
    details
  }) {
    return instantiate(SyntaxError, Object.assign({}, properties, {
      loc
    }), {
      clone(overrides = {}) {
        const loc = overrides.loc || {};
        return constructor({
          loc: new Position("line" in loc ? loc.line : this.loc.line, "column" in loc ? loc.column : this.loc.column, "index" in loc ? loc.index : this.loc.index),
          details: Object.assign({}, this.details, overrides.details)
        });
      },
      details: {
        value: details,
        enumerable: false
      },
      message: {
        get() {
          return `${toMessage(this.details)} (${this.loc.line}:${this.loc.column})`;
        },
        set(value) {
          Object.defineProperty(this, "message", {
            value
          });
        }
      },
      pos: {
        reflect: "loc.index",
        enumerable: true
      },
      missingPlugin: "missingPlugin" in details && {
        reflect: "details.missingPlugin",
        enumerable: true
      }
    });
  };
}
function ParseErrorEnum(argument, syntaxPlugin) {
  if (Array.isArray(argument)) {
    return parseErrorTemplates => ParseErrorEnum(parseErrorTemplates, argument[0]);
  }
  const ParseErrorConstructors = {};
  for (const reasonCode of Object.keys(argument)) {
    const template = argument[reasonCode];
    const _ref2 = typeof template === "string" ? {
        message: () => template
      } : typeof template === "function" ? {
        message: template
      } : template,
      {
        message
      } = _ref2,
      rest = _objectWithoutPropertiesLoose(_ref2, _excluded2$1);
    const toMessage = typeof message === "string" ? () => message : message;
    ParseErrorConstructors[reasonCode] = toParseErrorConstructor(Object.assign({
      code: ParseErrorCode.SyntaxError,
      reasonCode,
      toMessage
    }, syntaxPlugin ? {
      syntaxPlugin
    } : {}, rest));
  }
  return ParseErrorConstructors;
}
const Errors = Object.assign({}, ParseErrorEnum(ModuleErrors), ParseErrorEnum(StandardErrors), ParseErrorEnum(StrictModeErrors), ParseErrorEnum`pipelineOperator`(PipelineOperatorErrors));
const {
  defineProperty
} = Object;
const toUnenumerable = (object, key) => defineProperty(object, key, {
  enumerable: false,
  value: object[key]
});
function toESTreeLocation(node) {
  node.loc.start && toUnenumerable(node.loc.start, "index");
  node.loc.end && toUnenumerable(node.loc.end, "index");
  return node;
}
var estree = superClass => class ESTreeParserMixin 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 expression = directive.value;
    delete directive.value;
    expression.type = "Literal";
    expression.raw = expression.extra.raw;
    expression.value = expression.extra.expressionValue;
    const stmt = directive;
    stmt.type = "ExpressionStatement";
    stmt.expression = expression;
    stmt.directive = expression.extra.rawValue;
    delete expression.extra;
    return stmt;
  }
  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, allowDirectives, topLevel, end, afterBlockParse) {
    super.parseBlockBody(node, allowDirectives, topLevel, end, afterBlockParse);
    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;
    }
    return this.finishNode(node, "MethodDefinition");
  }
  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, startLoc, isPattern, refExpressionErrors) {
    const node = super.parseObjectProperty(prop, startLoc, isPattern, refExpressionErrors);
    if (node) {
      node.kind = "init";
      node.type = "Property";
    }
    return node;
  }
  isValidLVal(type, isUnparenthesizedInAssign, binding) {
    return type === "Property" ? "value" : super.isValidLVal(type, isUnparenthesizedInAssign, binding);
  }
  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);
    } else {
      super.toAssignable(node, isLHS);
    }
  }
  toAssignableObjectExpressionProp(prop, isLast, isLHS) {
    if (prop.kind === "get" || prop.kind === "set") {
      this.raise(Errors.PatternHasAccessor, {
        at: prop.key
      });
    } else if (prop.method) {
      this.raise(Errors.PatternHasMethod, {
        at: prop.key
      });
    } else {
      super.toAssignableObjectExpressionProp(prop, isLast, isLHS);
    }
  }
  finishCallExpression(unfinished, optional) {
    const node = super.finishCallExpression(unfinished, optional);
    if (node.callee.type === "Import") {
      node.type = "ImportExpression";
      node.source = node.arguments[0];
      if (this.hasPlugin("importAttributes") || 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(unfinished, decorators) {
    const exportStartLoc = this.state.lastTokStartLoc;
    const node = super.parseExport(unfinished, decorators);
    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;
        }
      case "ExportDefaultDeclaration":
        {
          var _declaration$decorato;
          const {
            declaration
          } = node;
          if ((declaration == null ? void 0 : declaration.type) === "ClassDeclaration" && ((_declaration$decorato = declaration.decorators) == null ? void 0 : _declaration$decorato.length) > 0 && declaration.start === node.start) {
            this.resetStartLocation(node, exportStartLoc);
          }
        }
        break;
    }
    return node;
  }
  parseSubscript(base, startLoc, noCalls, state) {
    const node = super.parseSubscript(base, 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);
  }
  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));
  }
  resetStartLocation(node, startLoc) {
    super.resetStartLocation(node, startLoc);
    toESTreeLocation(node);
  }
  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("<tag"),
  j_cTag: new TokContext("</tag"),
  j_expr: new TokContext("<tag>...</tag>", 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("}"),
  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
  }),
  _using: createKeywordLike("using", {
    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
  }),
  _satisfies: createKeywordLike("satisfies", {
    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 <= 130;
}
function tokenKeywordOrIdentifierIsKeyword(token) {
  return token <= 92;
}
function tokenIsKeywordOrIdentifier(token) {
  return token >= 58 && token <= 130;
}
function tokenIsLiteralPropertyName(token) {
  return token >= 58 && token <= 134;
}
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 >= 127 && token <= 129;
}
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 >= 119 && token <= 121;
}
function tokenIsTSDeclarationStart(token) {
  return token >= 122 && token <= 128;
}
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[140].updateContext = context => {
    context.push(types.j_expr, types.j_oTag);
  };
}
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\u0cf3\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-\u0ece\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, 20, 1, 64, 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, 16, 0, 2, 12, 2, 33, 125, 0, 80, 921, 103, 110, 18, 195, 2637, 96, 16, 1071, 18, 5, 4026, 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, 16, 0, 30, 2, 3, 0, 15, 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, 7, 5, 262, 61, 147, 44, 11, 6, 17, 0, 322, 29, 19, 43, 485, 27, 757, 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, 4153, 7, 221, 3, 5761, 15, 7472, 3104, 541, 1507, 4938, 6, 4191];
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, 81, 2, 71, 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, 3, 0, 158, 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, 10, 1, 2, 0, 49, 6, 4, 4, 14, 9, 5351, 0, 7, 14, 13835, 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, 101, 0, 161, 6, 10, 9, 357, 0, 62, 13, 499, 13, 983, 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_STATIC_BLOCK | SCOPE_TS_MODULE;
const BIND_KIND_VALUE = 0b0000000000001,
  BIND_KIND_TYPE = 0b0000000000010,
  BIND_SCOPE_VAR = 0b0000000000100,
  BIND_SCOPE_LEXICAL = 0b0000000001000,
  BIND_SCOPE_FUNCTION = 0b0000000010000,
  BIND_FLAGS_NONE = 0b00000001000000,
  BIND_FLAGS_CLASS = 0b00000010000000,
  BIND_FLAGS_TS_ENUM = 0b00000100000000,
  BIND_FLAGS_TS_CONST_ENUM = 0b00001000000000,
  BIND_FLAGS_TS_EXPORT_ONLY = 0b00010000000000,
  BIND_FLAGS_FLOW_DECLARE_FN = 0b00100000000000,
  BIND_FLAGS_TS_IMPORT = 0b01000000000000,
  BIND_FLAGS_NO_LET_IN_LEXICAL = 0b10000000000000;
const BIND_CLASS = BIND_KIND_VALUE | BIND_KIND_TYPE | BIND_SCOPE_LEXICAL | BIND_FLAGS_CLASS | BIND_FLAGS_NO_LET_IN_LEXICAL,
  BIND_LEXICAL = BIND_KIND_VALUE | 0 | BIND_SCOPE_LEXICAL | BIND_FLAGS_NO_LET_IN_LEXICAL,
  BIND_CATCH_PARAM = 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_FLAGS_NO_LET_IN_LEXICAL,
  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_TS_TYPE_IMPORT = 0 | BIND_KIND_TYPE | 0 | BIND_FLAGS_TS_IMPORT,
  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(parser, inModule) {
    this.parser = void 0;
    this.scopeStack = [];
    this.inModule = void 0;
    this.undefinedExports = new Map();
    this.parser = parser;
    this.inModule = inModule;
  }
  get inTopLevel() {
    return (this.currentScope().flags & SCOPE_PROGRAM) > 0;
  }
  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() {
    const scope = this.scopeStack.pop();
    return scope.flags;
  }
  treatFunctionsAsVarInScope(scope) {
    return !!(scope.flags & (SCOPE_FUNCTION | SCOPE_STATIC_BLOCK) || !this.parser.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.parser.inModule && scope.flags & SCOPE_PROGRAM) {
      this.undefinedExports.delete(name);
    }
  }
  maybeExportDefined(scope, name) {
    if (this.parser.inModule && scope.flags & SCOPE_PROGRAM) {
      this.undefinedExports.delete(name);
    }
  }
  checkRedeclarationInScope(scope, name, bindingType, loc) {
    if (this.isRedeclaredInScope(scope, name, bindingType)) {
      this.parser.raise(Errors.VarRedeclaration, {
        at: loc,
        identifierName: 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(name, bindingType, loc);
  }
  isRedeclaredInScope(scope, name, bindingType) {
    if (super.isRedeclaredInScope(scope, name, bindingType)) 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);
    }
  }
}
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;
    }
  }
  resetPreviousIdentifierLeadingComments(node) {
    const {
      commentStack
    } = this.state;
    const {
      length
    } = commentStack;
    if (length === 0) return;
    if (commentStack[length - 1].trailingNode === node) {
      commentStack[length - 1].trailingNode = null;
    } else if (length >= 2 && commentStack[length - 2].trailingNode === node) {
      commentStack[length - 2].trailingNode = 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 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]|\/\/.*|\/\*.*?\*\/)*/g;
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.inDisallowConditionalTypesContext = false;
    this.topicContext = {
      maxNumOfResolvableTopics: 0,
      maxTopicIndex: null
    };
    this.soloAwait = false;
    this.inFSharpPipelineDirectBody = false;
    this.labels = [];
    this.comments = [];
    this.commentStack = [];
    this.pos = 0;
    this.type = 137;
    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.firstInvalidTemplateEscapePos = null;
    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 forbiddenNumericSeparatorSiblings = {
  decBinOct: new Set([46, 66, 69, 79, 95, 98, 101, 111]),
  hex: new Set([46, 88, 95, 120])
};
const isAllowedNumericSeparatorSibling = {
  bin: ch => ch === 48 || ch === 49,
  oct: ch => ch >= 48 && ch <= 55,
  dec: ch => ch >= 48 && ch <= 57,
  hex: ch => ch >= 48 && ch <= 57 || ch >= 65 && ch <= 70 || ch >= 97 && ch <= 102
};
function readStringContents(type, input, pos, lineStart, curLine, errors) {
  const initialPos = pos;
  const initialLineStart = lineStart;
  const initialCurLine = curLine;
  let out = "";
  let firstInvalidLoc = null;
  let chunkStart = pos;
  const {
    length
  } = input;
  for (;;) {
    if (pos >= length) {
      errors.unterminated(initialPos, initialLineStart, initialCurLine);
      out += input.slice(chunkStart, pos);
      break;
    }
    const ch = input.charCodeAt(pos);
    if (isStringEnd(type, ch, input, pos)) {
      out += input.slice(chunkStart, pos);
      break;
    }
    if (ch === 92) {
      out += input.slice(chunkStart, pos);
      const res = readEscapedChar(input, pos, lineStart, curLine, type === "template", errors);
      if (res.ch === null && !firstInvalidLoc) {
        firstInvalidLoc = {
          pos,
          lineStart,
          curLine
        };
      } else {
        out += res.ch;
      }
      ({
        pos,
        lineStart,
        curLine
      } = res);
      chunkStart = pos;
    } else if (ch === 8232 || ch === 8233) {
      ++pos;
      ++curLine;
      lineStart = pos;
    } else if (ch === 10 || ch === 13) {
      if (type === "template") {
        out += input.slice(chunkStart, pos) + "\n";
        ++pos;
        if (ch === 13 && input.charCodeAt(pos) === 10) {
          ++pos;
        }
        ++curLine;
        chunkStart = lineStart = pos;
      } else {
        errors.unterminated(initialPos, initialLineStart, initialCurLine);
      }
    } else {
      ++pos;
    }
  }
  return {
    pos,
    str: out,
    firstInvalidLoc,
    lineStart,
    curLine,
    containsInvalid: !!firstInvalidLoc
  };
}
function isStringEnd(type, ch, input, pos) {
  if (type === "template") {
    return ch === 96 || ch === 36 && input.charCodeAt(pos + 1) === 123;
  }
  return ch === (type === "double" ? 34 : 39);
}
function readEscapedChar(input, pos, lineStart, curLine, inTemplate, errors) {
  const throwOnInvalid = !inTemplate;
  pos++;
  const res = ch => ({
    pos,
    ch,
    lineStart,
    curLine
  });
  const ch = input.charCodeAt(pos++);
  switch (ch) {
    case 110:
      return res("\n");
    case 114:
      return res("\r");
    case 120:
      {
        let code;
        ({
          code,
          pos
        } = readHexChar(input, pos, lineStart, curLine, 2, false, throwOnInvalid, errors));
        return res(code === null ? null : String.fromCharCode(code));
      }
    case 117:
      {
        let code;
        ({
          code,
          pos
        } = readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors));
        return res(code === null ? null : String.fromCodePoint(code));
      }
    case 116:
      return res("\t");
    case 98:
      return res("\b");
    case 118:
      return res("\u000b");
    case 102:
      return res("\f");
    case 13:
      if (input.charCodeAt(pos) === 10) {
        ++pos;
      }
    case 10:
      lineStart = pos;
      ++curLine;
    case 8232:
    case 8233:
      return res("");
    case 56:
    case 57:
      if (inTemplate) {
        return res(null);
      } else {
        errors.strictNumericEscape(pos - 1, lineStart, curLine);
      }
    default:
      if (ch >= 48 && ch <= 55) {
        const startPos = pos - 1;
        const match = input.slice(startPos, pos + 2).match(/^[0-7]+/);
        let octalStr = match[0];
        let octal = parseInt(octalStr, 8);
        if (octal > 255) {
          octalStr = octalStr.slice(0, -1);
          octal = parseInt(octalStr, 8);
        }
        pos += octalStr.length - 1;
        const next = input.charCodeAt(pos);
        if (octalStr !== "0" || next === 56 || next === 57) {
          if (inTemplate) {
            return res(null);
          } else {
            errors.strictNumericEscape(startPos, lineStart, curLine);
          }
        }
        return res(String.fromCharCode(octal));
      }
      return res(String.fromCharCode(ch));
  }
}
function readHexChar(input, pos, lineStart, curLine, len, forceLen, throwOnInvalid, errors) {
  const initialPos = pos;
  let n;
  ({
    n,
    pos
  } = readInt(input, pos, lineStart, curLine, 16, len, forceLen, false, errors, !throwOnInvalid));
  if (n === null) {
    if (throwOnInvalid) {
      errors.invalidEscapeSequence(initialPos, lineStart, curLine);
    } else {
      pos = initialPos - 1;
    }
  }
  return {
    code: n,
    pos
  };
}
function readInt(input, pos, lineStart, curLine, radix, len, forceLen, allowNumSeparator, errors, bailOnError) {
  const start = pos;
  const forbiddenSiblings = radix === 16 ? forbiddenNumericSeparatorSiblings.hex : forbiddenNumericSeparatorSiblings.decBinOct;
  const isAllowedSibling = radix === 16 ? isAllowedNumericSeparatorSibling.hex : radix === 10 ? isAllowedNumericSeparatorSibling.dec : radix === 8 ? isAllowedNumericSeparatorSibling.oct : isAllowedNumericSeparatorSibling.bin;
  let invalid = false;
  let total = 0;
  for (let i = 0, e = len == null ? Infinity : len; i < e; ++i) {
    const code = input.charCodeAt(pos);
    let val;
    if (code === 95 && allowNumSeparator !== "bail") {
      const prev = input.charCodeAt(pos - 1);
      const next = input.charCodeAt(pos + 1);
      if (!allowNumSeparator) {
        if (bailOnError) return {
          n: null,
          pos
        };
        errors.numericSeparatorInEscapeSequence(pos, lineStart, curLine);
      } else if (Number.isNaN(next) || !isAllowedSibling(next) || forbiddenSiblings.has(prev) || forbiddenSiblings.has(next)) {
        if (bailOnError) return {
          n: null,
          pos
        };
        errors.unexpectedNumericSeparator(pos, lineStart, curLine);
      }
      ++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 (val <= 9 && bailOnError) {
        return {
          n: null,
          pos
        };
      } else if (val <= 9 && errors.invalidDigit(pos, lineStart, curLine, radix)) {
        val = 0;
      } else if (forceLen) {
        val = 0;
        invalid = true;
      } else {
        break;
      }
    }
    ++pos;
    total = total * radix + val;
  }
  if (pos === start || len != null && pos - start !== len || invalid) {
    return {
      n: null,
      pos
    };
  }
  return {
    n: total,
    pos
  };
}
function readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors) {
  const ch = input.charCodeAt(pos);
  let code;
  if (ch === 123) {
    ++pos;
    ({
      code,
      pos
    } = readHexChar(input, pos, lineStart, curLine, input.indexOf("}", pos) - pos, true, throwOnInvalid, errors));
    ++pos;
    if (code !== null && code > 0x10ffff) {
      if (throwOnInvalid) {
        errors.invalidCodePoint(pos, lineStart, curLine);
      } else {
        return {
          code: null,
          pos
        };
      }
    }
  } else {
    ({
      code,
      pos
    } = readHexChar(input, pos, lineStart, curLine, 4, false, throwOnInvalid, errors));
  }
  return {
    code,
    pos
  };
}
const _excluded = ["at"],
  _excluded2 = ["at"];
function buildPosition(pos, lineStart, curLine) {
  return new Position(curLine, pos - lineStart, pos);
}
const VALID_REGEX_FLAGS = new Set([103, 109, 115, 105, 121, 117, 100, 118]);
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 CommentsParser {
  constructor(options, input) {
    super();
    this.isLookahead = void 0;
    this.tokens = [];
    this.errorHandlers_readInt = {
      invalidDigit: (pos, lineStart, curLine, radix) => {
        if (!this.options.errorRecovery) return false;
        this.raise(Errors.InvalidDigit, {
          at: buildPosition(pos, lineStart, curLine),
          radix
        });
        return true;
      },
      numericSeparatorInEscapeSequence: this.errorBuilder(Errors.NumericSeparatorInEscapeSequence),
      unexpectedNumericSeparator: this.errorBuilder(Errors.UnexpectedNumericSeparator)
    };
    this.errorHandlers_readCodePoint = Object.assign({}, this.errorHandlers_readInt, {
      invalidEscapeSequence: this.errorBuilder(Errors.InvalidEscapeSequence),
      invalidCodePoint: this.errorBuilder(Errors.InvalidCodePoint)
    });
    this.errorHandlers_readStringContents_string = Object.assign({}, this.errorHandlers_readCodePoint, {
      strictNumericEscape: (pos, lineStart, curLine) => {
        this.recordStrictModeErrors(Errors.StrictNumericEscape, {
          at: buildPosition(pos, lineStart, curLine)
        });
      },
      unterminated: (pos, lineStart, curLine) => {
        throw this.raise(Errors.UnterminatedString, {
          at: buildPosition(pos - 1, lineStart, curLine)
        });
      }
    });
    this.errorHandlers_readStringContents_template = Object.assign({}, this.errorHandlers_readCodePoint, {
      strictNumericEscape: this.errorBuilder(Errors.StrictNumericEscape),
      unterminated: (pos, lineStart, curLine) => {
        throw this.raise(Errors.UnterminatedTemplate, {
          at: buildPosition(pos, lineStart, curLine)
        });
      }
    });
    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());
  }
  nextTokenInLineStart() {
    return this.nextTokenInLineStartSince(this.state.pos);
  }
  nextTokenInLineStartSince(pos) {
    skipWhiteSpaceInLine.lastIndex = pos;
    return skipWhiteSpaceInLine.test(this.input) ? skipWhiteSpaceInLine.lastIndex : pos;
  }
  lookaheadInLineCharCode() {
    return this.input.charCodeAt(this.nextTokenInLineStart());
  }
  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(([toParseError, at]) => this.raise(toParseError, {
        at
      }));
      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(137);
      return;
    }
    this.getTokenFromCode(this.codePointAtPos(this.state.pos));
  }
  skipBlockComment(commentEnd) {
    let startLoc;
    if (!this.isLookahead) startLoc = this.state.curPosition();
    const start = this.state.pos;
    const end = this.input.indexOf(commentEnd, start + 2);
    if (end === -1) {
      throw this.raise(Errors.UnterminatedComment, {
        at: this.state.curPosition()
      });
    }
    this.state.pos = end + commentEnd.length;
    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 + commentEnd.length,
      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 && this.options.annexB) {
            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 && this.options.annexB) {
            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(Errors.UnexpectedDigitAfterHash, {
        at: this.state.curPosition()
      });
    }
    if (next === 123 || next === 91 && this.hasPlugin("recordAndTuple")) {
      this.expectPlugin("recordAndTuple");
      if (this.getPluginOption("recordAndTuple", "syntaxType") === "bar") {
        throw this.raise(next === 123 ? Errors.RecordExpressionHashIncorrectStartSyntaxType : Errors.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(136, this.readWord1(next));
    } else if (next === 92) {
      ++this.state.pos;
      this.finishToken(136, 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(Errors.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(Errors.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) {
        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(Errors.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(Errors.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(Errors.InvalidOrUnexpectedToken, {
      at: this.state.curPosition(),
      unexpected: 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(Errors.UnterminatedRegExp, {
          at: createPositionWithColumnOffset(startLoc, 1)
        });
      }
      const ch = this.input.charCodeAt(pos);
      if (isNewLine(ch)) {
        throw this.raise(Errors.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) {
          if (mods.includes("u")) {
            this.raise(Errors.IncompatibleRegExpUVFlags, {
              at: nextPos()
            });
          }
        } else if (cp === 117) {
          if (mods.includes("v")) {
            this.raise(Errors.IncompatibleRegExpUVFlags, {
              at: nextPos()
            });
          }
        }
        if (mods.includes(char)) {
          this.raise(Errors.DuplicateRegExpFlags, {
            at: nextPos()
          });
        }
      } else if (isIdentifierChar(cp) || cp === 92) {
        this.raise(Errors.MalformedRegExpFlags, {
          at: nextPos()
        });
      } else {
        break;
      }
      ++pos;
      mods += char;
    }
    this.state.pos = pos;
    this.finishToken(135, {
      pattern: content,
      flags: mods
    });
  }
  readInt(radix, len, forceLen = false, allowNumSeparator = true) {
    const {
      n,
      pos
    } = readInt(this.input, this.state.pos, this.state.lineStart, this.state.curLine, radix, len, forceLen, allowNumSeparator, this.errorHandlers_readInt, false);
    this.state.pos = pos;
    return n;
  }
  readRadixNumber(radix) {
    const startLoc = this.state.curPosition();
    let isBigInt = false;
    this.state.pos += 2;
    const val = this.readInt(radix);
    if (val == null) {
      this.raise(Errors.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(Errors.InvalidDecimal, {
        at: startLoc
      });
    }
    if (isIdentifierStart(this.codePointAtPos(this.state.pos))) {
      throw this.raise(Errors.NumberIdentifier, {
        at: this.state.curPosition()
      });
    }
    if (isBigInt) {
      const str = this.input.slice(startLoc.index, this.state.pos).replace(/[_n]/g, "");
      this.finishToken(133, str);
      return;
    }
    this.finishToken(132, 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(Errors.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(Errors.StrictOctalLiteral, {
        at: startLoc
      });
      if (!this.state.strict) {
        const underscorePos = integer.indexOf("_");
        if (underscorePos > 0) {
          this.raise(Errors.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(Errors.InvalidOrMissingExponent, {
          at: startLoc
        });
      }
      isFloat = true;
      hasExponent = true;
      next = this.input.charCodeAt(this.state.pos);
    }
    if (next === 110) {
      if (isFloat || hasLeadingZero) {
        this.raise(Errors.InvalidBigIntLiteral, {
          at: startLoc
        });
      }
      ++this.state.pos;
      isBigInt = true;
    }
    if (next === 109) {
      this.expectPlugin("decimal", this.state.curPosition());
      if (hasExponent || hasLeadingZero) {
        this.raise(Errors.InvalidDecimal, {
          at: startLoc
        });
      }
      ++this.state.pos;
      isDecimal = true;
    }
    if (isIdentifierStart(this.codePointAtPos(this.state.pos))) {
      throw this.raise(Errors.NumberIdentifier, {
        at: this.state.curPosition()
      });
    }
    const str = this.input.slice(start, this.state.pos).replace(/[_mn]/g, "");
    if (isBigInt) {
      this.finishToken(133, str);
      return;
    }
    if (isDecimal) {
      this.finishToken(134, str);
      return;
    }
    const val = isOctal ? parseInt(str, 8) : parseFloat(str);
    this.finishToken(132, val);
  }
  readCodePoint(throwOnInvalid) {
    const {
      code,
      pos
    } = readCodePoint(this.input, this.state.pos, this.state.lineStart, this.state.curLine, throwOnInvalid, this.errorHandlers_readCodePoint);
    this.state.pos = pos;
    return code;
  }
  readString(quote) {
    const {
      str,
      pos,
      curLine,
      lineStart
    } = readStringContents(quote === 34 ? "double" : "single", this.input, this.state.pos + 1, this.state.lineStart, this.state.curLine, this.errorHandlers_readStringContents_string);
    this.state.pos = pos + 1;
    this.state.lineStart = lineStart;
    this.state.curLine = curLine;
    this.finishToken(131, str);
  }
  readTemplateContinuation() {
    if (!this.match(8)) {
      this.unexpected(null, 8);
    }
    this.state.pos--;
    this.readTemplateToken();
  }
  readTemplateToken() {
    const opening = this.input[this.state.pos];
    const {
      str,
      firstInvalidLoc,
      pos,
      curLine,
      lineStart
    } = readStringContents("template", this.input, this.state.pos + 1, this.state.lineStart, this.state.curLine, this.errorHandlers_readStringContents_template);
    this.state.pos = pos + 1;
    this.state.lineStart = lineStart;
    this.state.curLine = curLine;
    if (firstInvalidLoc) {
      this.state.firstInvalidTemplateEscapePos = new Position(firstInvalidLoc.curLine, firstInvalidLoc.pos - firstInvalidLoc.lineStart, firstInvalidLoc.pos);
    }
    if (this.input.codePointAt(pos) === 96) {
      this.finishToken(24, firstInvalidLoc ? null : opening + str + "`");
    } else {
      this.state.pos++;
      this.finishToken(25, firstInvalidLoc ? null : opening + str + "${");
    }
  }
  recordStrictModeErrors(toParseError, {
    at
  }) {
    const index = at.index;
    if (this.state.strict && !this.state.strictErrors.has(index)) {
      this.raise(toParseError, {
        at
      });
    } else {
      this.state.strictErrors.set(index, [toParseError, at]);
    }
  }
  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(Errors.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(Errors.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(130, word);
    }
  }
  checkKeywordEscapes() {
    const {
      type
    } = this.state;
    if (tokenIsKeyword(type) && this.state.containsEsc) {
      this.raise(Errors.InvalidEscapedReservedWord, {
        at: this.state.startLoc,
        reservedWord: tokenLabelName(type)
      });
    }
  }
  raise(toParseError, raiseProperties) {
    const {
        at
      } = raiseProperties,
      details = _objectWithoutPropertiesLoose(raiseProperties, _excluded);
    const loc = at instanceof Position ? at : at.loc.start;
    const error = toParseError({
      loc,
      details
    });
    if (!this.options.errorRecovery) throw error;
    if (!this.isLookahead) this.state.errors.push(error);
    return error;
  }
  raiseOverwrite(toParseError, raiseProperties) {
    const {
        at
      } = raiseProperties,
      details = _objectWithoutPropertiesLoose(raiseProperties, _excluded2);
    const loc = at instanceof Position ? at : at.loc.start;
    const pos = loc.index;
    const errors = this.state.errors;
    for (let i = errors.length - 1; i >= 0; i--) {
      const error = errors[i];
      if (error.loc.index === pos) {
        return errors[i] = toParseError({
          loc,
          details
        });
      }
      if (error.loc.index < pos) break;
    }
    return this.raise(toParseError, raiseProperties);
  }
  updateContext(prevType) {}
  unexpected(loc, type) {
    throw this.raise(Errors.UnexpectedToken, {
      expected: type ? tokenLabelName(type) : null,
      at: loc != null ? loc : this.state.startLoc
    });
  }
  expectPlugin(pluginName, loc) {
    if (this.hasPlugin(pluginName)) {
      return true;
    }
    throw this.raise(Errors.MissingPlugin, {
      at: loc != null ? loc : this.state.startLoc,
      missingPlugin: [pluginName]
    });
  }
  expectOnePlugin(pluginNames) {
    if (!pluginNames.some(name => this.hasPlugin(name))) {
      throw this.raise(Errors.MissingOneOfPlugins, {
        at: this.state.startLoc,
        missingPlugin: pluginNames
      });
    }
  }
  errorBuilder(error) {
    return (pos, lineStart, curLine) => {
      this.raise(error, {
        at: buildPosition(pos, lineStart, curLine)
      });
    };
  }
}
class ClassScope {
  constructor() {
    this.privateNames = new Set();
    this.loneAccessors = new Map();
    this.undefinedPrivateNames = new Map();
  }
}
class ClassScopeHandler {
  constructor(parser) {
    this.parser = void 0;
    this.stack = [];
    this.undefinedPrivateNames = new Map();
    this.parser = parser;
  }
  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.parser.raise(Errors.InvalidPrivateFieldResolution, {
          at: loc,
          identifierName: 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.parser.raise(Errors.PrivateNameRedeclaration, {
        at: loc,
        identifierName: 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.parser.raise(Errors.InvalidPrivateFieldResolution, {
        at: loc,
        identifierName: 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.declarationErrors = new Map();
  }
  recordDeclarationError(ParsingErrorClass, {
    at
  }) {
    const index = at.index;
    this.declarationErrors.set(index, [ParsingErrorClass, at]);
  }
  clearDeclarationError(index) {
    this.declarationErrors.delete(index);
  }
  iterateErrors(iterator) {
    this.declarationErrors.forEach(iterator);
  }
}
class ExpressionScopeHandler {
  constructor(parser) {
    this.parser = void 0;
    this.stack = [new ExpressionScope()];
    this.parser = parser;
  }
  enter(scope) {
    this.stack.push(scope);
  }
  exit() {
    this.stack.pop();
  }
  recordParameterInitializerError(toParseError, {
    at: node
  }) {
    const origin = {
      at: node.loc.start
    };
    const {
      stack
    } = this;
    let i = stack.length - 1;
    let scope = stack[i];
    while (!scope.isCertainlyParameterDeclaration()) {
      if (scope.canBeArrowParameterDeclaration()) {
        scope.recordDeclarationError(toParseError, origin);
      } else {
        return;
      }
      scope = stack[--i];
    }
    this.parser.raise(toParseError, origin);
  }
  recordArrowParameterBindingError(error, {
    at: node
  }) {
    const {
      stack
    } = this;
    const scope = stack[stack.length - 1];
    const origin = {
      at: node.loc.start
    };
    if (scope.isCertainlyParameterDeclaration()) {
      this.parser.raise(error, origin);
    } else if (scope.canBeArrowParameterDeclaration()) {
      scope.recordDeclarationError(error, origin);
    } else {
      return;
    }
  }
  recordAsyncArrowParametersError({
    at
  }) {
    const {
      stack
    } = this;
    let i = stack.length - 1;
    let scope = stack[i];
    while (scope.canBeArrowParameterDeclaration()) {
      if (scope.type === kMaybeAsyncArrowParameterDeclaration) {
        scope.recordDeclarationError(Errors.AwaitBindingIdentifier, {
          at
        });
      }
      scope = stack[--i];
    }
  }
  validateAsPattern() {
    const {
      stack
    } = this;
    const currentScope = stack[stack.length - 1];
    if (!currentScope.canBeArrowParameterDeclaration()) return;
    currentScope.iterateErrors(([toParseError, loc]) => {
      this.parser.raise(toParseError, {
        at: loc
      });
      let i = stack.length - 2;
      let scope = stack[i];
      while (scope.canBeArrowParameterDeclaration()) {
        scope.clearDeclarationError(loc.index);
        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, toParseError) {
    if (!this.eatContextual(token)) {
      if (toParseError != null) {
        throw this.raise(toParseError, {
          at: this.state.startLoc
        });
      }
      this.unexpected(null, token);
    }
  }
  canInsertSemicolon() {
    return this.match(137) || 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(Errors.MissingSemicolon, {
      at: this.state.lastTokEndLoc
    });
  }
  expect(type, loc) {
    this.eat(type) || this.unexpected(loc, type);
  }
  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(Errors.InvalidCoverInitializedName, {
        at: shorthandAssignLoc
      });
    }
    if (doubleProtoLoc != null) {
      this.raise(Errors.DuplicateProto, {
        at: doubleProtoLoc
      });
    }
    if (privateKeyLoc != null) {
      this.raise(Errors.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);
  }
  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, inModule);
    const oldProdParam = this.prodParam;
    this.prodParam = new ProductionParameterHandler();
    const oldClassScope = this.classScope;
    this.classScope = new ClassScopeHandler(this);
    const oldExpressionScope = this.expressionScope;
    this.expressionScope = new ExpressionScopeHandler(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(undefined, this.start, this.loc.start);
    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(loc) {
    return new Node(this, loc.index, loc);
  }
  startNodeAtNode(type) {
    return this.startNodeAt(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, startLoc) {
    node.start = startLoc.index;
    node.loc.start = startLoc;
    if (this.options.ranges) node.range[0] = startLoc.index;
  }
  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.loc.start);
  }
}
const reservedTypes = new Set(["_", "any", "bool", "boolean", "empty", "extends", "false", "interface", "mixed", "null", "number", "static", "string", "true", "typeof", "void"]);
const FlowErrors = ParseErrorEnum`flow`({
  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: ({
    reservedType
  }) => `Cannot overwrite reserved type ${reservedType}.`,
  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: ({
    memberName,
    enumName
  }) => `Boolean enum members need to be initialized. Use either \`${memberName} = true,\` or \`${memberName} = false,\` in enum \`${enumName}\`.`,
  EnumDuplicateMemberName: ({
    memberName,
    enumName
  }) => `Enum member names need to be unique, but the name \`${memberName}\` has already been used before in enum \`${enumName}\`.`,
  EnumInconsistentMemberValues: ({
    enumName
  }) => `Enum \`${enumName}\` has inconsistent member initializers. Either use no initializers, or consistently use literals (either booleans, numbers, or strings) for all member initializers.`,
  EnumInvalidExplicitType: ({
    invalidEnumType,
    enumName
  }) => `Enum type \`${invalidEnumType}\` is not valid. Use one of \`boolean\`, \`number\`, \`string\`, or \`symbol\` in enum \`${enumName}\`.`,
  EnumInvalidExplicitTypeUnknownSupplied: ({
    enumName
  }) => `Supplied enum type is not valid. Use one of \`boolean\`, \`number\`, \`string\`, or \`symbol\` in enum \`${enumName}\`.`,
  EnumInvalidMemberInitializerPrimaryType: ({
    enumName,
    memberName,
    explicitType
  }) => `Enum \`${enumName}\` has type \`${explicitType}\`, so the initializer of \`${memberName}\` needs to be a ${explicitType} literal.`,
  EnumInvalidMemberInitializerSymbolType: ({
    enumName,
    memberName
  }) => `Symbol enum members cannot be initialized. Use \`${memberName},\` in enum \`${enumName}\`.`,
  EnumInvalidMemberInitializerUnknownType: ({
    enumName,
    memberName
  }) => `The enum member initializer for \`${memberName}\` needs to be a literal (either a boolean, number, or string) in enum \`${enumName}\`.`,
  EnumInvalidMemberName: ({
    enumName,
    memberName,
    suggestion
  }) => `Enum member names cannot start with lowercase 'a' through 'z'. Instead of using \`${memberName}\`, consider using \`${suggestion}\`, in enum \`${enumName}\`.`,
  EnumNumberMemberNotInitialized: ({
    enumName,
    memberName
  }) => `Number enum members need to be initialized, e.g. \`${memberName} = 1\` in enum \`${enumName}\`.`,
  EnumStringMemberInconsistentlyInitailized: ({
    enumName
  }) => `String enum members need to consistently either all use initializers, or use no initializers, in enum \`${enumName}\`.`,
  GetterMayNotHaveThisParam: "A getter cannot have a `this` parameter.",
  ImportReflectionHasImportType: "An `import module` declaration can not use `type` or `typeof` keyword.",
  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: Object.assign({
    message: "A binding pattern parameter cannot be optional in an implementation signature."
  }, {
    reasonCode: "OptionalBindingPattern"
  }),
  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: ({
    reservedType
  }) => `Unexpected reserved type ${reservedType}.`,
  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 `<T> async () => {}`, use `async <T>() => {}`.",
  UnsupportedDeclareExportKind: ({
    unsupportedExportKind,
    suggestion
  }) => `\`declare export ${unsupportedExportKind}\` is not supported. Use \`${suggestion}\` instead.`,
  UnsupportedStatementInDeclareModule: "Only declares and type imports are allowed inside declare module.",
  UnterminatedFlowComment: "Unterminated flow-comment."
});
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";
}
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 FlowParserMixin 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 !== 131 && type !== 13 && type !== 28) {
      if (this.flowPragma === undefined) {
        this.flowPragma = null;
      }
    }
    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");
      }
    }
    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(108);
    if (this.state.lastTokStart > moduloLoc.index + 1) {
      this.raise(FlowErrors.UnexpectedSpaceBetweenModuloChecks, {
        at: moduloLoc
      });
    }
    if (this.eat(10)) {
      node.value = super.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(125)) {
      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(128)) {
      return this.flowParseDeclareTypeAlias(node);
    } else if (this.isContextual(129)) {
      return this.flowParseDeclareOpaqueType(node);
    } else if (this.isContextual(127)) {
      return this.flowParseDeclareInterface(node);
    } else if (this.match(82)) {
      return this.flowParseDeclareExportDeclaration(node, insideModule);
    } else {
      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(131)) {
      node.id = super.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(128) && !this.match(87)) {
          this.raise(FlowErrors.InvalidNonTypeImportInDeclareModule, {
            at: this.state.lastTokStartLoc
          });
        }
        super.parseImport(bodyNode);
      } else {
        this.expectContextual(123, 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, {
            at: bodyElement
          });
        }
        kind = "ES";
      } else if (bodyElement.type === "DeclareModuleExports") {
        if (hasModuleExport) {
          this.raise(FlowErrors.DuplicateDeclareModuleExports, {
            at: bodyElement
          });
        }
        if (kind === "ES") {
          this.raise(FlowErrors.AmbiguousDeclareModuleKind, {
            at: 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(128) || this.isContextual(127)) && !insideModule) {
        const label = this.state.value;
        throw this.raise(FlowErrors.UnsupportedDeclareExportKind, {
          at: this.state.startLoc,
          unsupportedExportKind: label,
          suggestion: exportSuggestions[label]
        });
      }
      if (this.match(74) || this.match(68) || this.match(80) || this.isContextual(129)) {
        node.declaration = this.flowParseDeclare(this.startNode());
        node.default = false;
        return this.finishNode(node, "DeclareExportDeclaration");
      } else if (this.match(55) || this.match(5) || this.isContextual(127) || this.isContextual(128) || this.isContextual(129)) {
        node = this.parseExport(node, null);
        if (node.type === "ExportNamedDeclaration") {
          node.type = "ExportDeclaration";
          node.default = false;
          delete node.exportKind;
        }
        node.type = "Declare" + node.type;
        return node;
      }
    }
    this.unexpected();
  }
  flowParseDeclareModuleExports(node) {
    this.next();
    this.expectContextual(109);
    node.typeAnnotation = this.flowParseTypeAnnotation();
    this.semicolon();
    return this.finishNode(node, "DeclareModuleExports");
  }
  flowParseDeclareTypeAlias(node) {
    this.next();
    const finished = this.flowParseTypeAlias(node);
    finished.type = "DeclareTypeAlias";
    return finished;
  }
  flowParseDeclareOpaqueType(node) {
    this.next();
    const finished = this.flowParseOpaqueType(node, true);
    finished.type = "DeclareOpaqueType";
    return finished;
  }
  flowParseDeclareInterface(node) {
    this.next();
    this.flowParseInterfaceish(node, false);
    return this.finishNode(node, "DeclareInterface");
  }
  flowParseInterfaceish(node, isClass) {
    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 = [];
    if (this.eat(81)) {
      do {
        node.extends.push(this.flowParseInterfaceExtends());
      } while (!isClass && this.eat(12));
    }
    if (isClass) {
      node.implements = [];
      node.mixins = [];
      if (this.eatContextual(115)) {
        do {
          node.mixins.push(this.flowParseInterfaceExtends());
        } while (this.eat(12));
      }
      if (this.eatContextual(111)) {
        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, false);
    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,
      reservedType: 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(128);
    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(140)) {
      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(127);
    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(132) || this.match(131) ? super.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.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(116)) {
        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, {
            at: 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, {
          at: 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.loc.start));
        if (kind === "get" || kind === "set") {
          this.flowCheckGetterSetterParams(node);
        }
        if (!allowSpread && node.key.name === "constructor" && node.value.this) {
          this.raise(FlowErrors.ThisParamBannedInConstructor, {
            at: 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, {
        at: property.value.this
      });
    }
    if (length !== paramCount) {
      this.raise(property.kind === "get" ? Errors.BadGetterArity : Errors.BadSetterArity, {
        at: property
      });
    }
    if (property.kind === "set" && property.value.rest) {
      this.raise(Errors.BadSetterRestParameter, {
        at: property
      });
    }
  }
  flowObjectTypeSemicolon() {
    if (!this.eat(13) && !this.eat(12) && !this.match(8) && !this.match(9)) {
      this.unexpected();
    }
  }
  flowParseQualifiedTypeIdentifier(startLoc, id) {
    var _startLoc;
    (_startLoc = startLoc) != null ? _startLoc : startLoc = this.state.startLoc;
    let node = id || this.flowParseRestrictedIdentifier(true);
    while (this.eat(16)) {
      const node2 = this.startNodeAt(startLoc);
      node2.qualification = node;
      node2.id = this.flowParseRestrictedIdentifier(true);
      node = this.finishNode(node2, "QualifiedTypeIdentifier");
    }
    return node;
  }
  flowParseGenericType(startLoc, id) {
    const node = this.startNodeAt(startLoc);
    node.typeParameters = null;
    node.id = this.flowParseQualifiedTypeIdentifier(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, {
          at: node
        });
      }
      name = this.parseIdentifier(isThis);
      if (this.eat(17)) {
        optional = true;
        if (isThis) {
          this.raise(FlowErrors.ThisParamMayNotBeOptional, {
            at: 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.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(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(startLoc, id);
    }
  }
  flowParsePrimaryType() {
    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 131:
        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(132)) {
            return this.parseLiteralAtNode(-this.state.value, "NumberLiteralTypeAnnotation", node);
          }
          if (this.match(133)) {
            return this.parseLiteralAtNode(-this.state.value, "BigIntLiteralTypeAnnotation", node);
          }
          throw this.raise(FlowErrors.UnexpectedSubtractionOperand, {
            at: this.state.startLoc
          });
        }
        this.unexpected();
        return;
      case 132:
        return this.parseLiteral(this.state.value, "NumberLiteralTypeAnnotation");
      case 133:
        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(127)) {
            return this.flowParseInterfaceType();
          }
          return this.flowIdentToTypeAnnotation(startLoc, node, this.parseIdentifier());
        }
    }
    this.unexpected();
  }
  flowParsePostfixType() {
    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(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.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 === 130 && this.state.value === "_") {
      const startLoc = this.state.startLoc;
      const node = this.parseIdentifier();
      return this.flowParseGenericType(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();
      return this.finishNode(variance, "Variance");
    }
    return variance;
  }
  parseFunctionBody(node, allowExpressionBody, isMethod = false) {
    if (allowExpressionBody) {
      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;
    }
    return super.parseFunctionBodyAndFinish(node, type, isMethod);
  }
  parseStatementLike(flags) {
    if (this.state.strict && this.isContextual(127)) {
      const lookahead = this.lookahead();
      if (tokenIsKeywordOrIdentifier(lookahead.type)) {
        const node = this.startNode();
        this.next();
        return this.flowParseInterface(node);
      }
    } else if (this.shouldParseEnums() && this.isContextual(124)) {
      const node = this.startNode();
      this.next();
      return this.flowParseEnumDeclaration(node);
    }
    const stmt = super.parseStatementLike(flags);
    if (this.flowPragma === undefined && !this.isValidDirective(stmt)) {
      this.flowPragma = null;
    }
    return stmt;
  }
  parseExpressionStatement(node, expr, decorators) {
    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, decorators);
  }
  shouldParseExportDeclaration() {
    const {
      type
    } = this.state;
    if (tokenIsFlowInterfaceOrTypeOrOpaque(type) || this.shouldParseEnums() && type === 124) {
      return !this.state.containsEsc;
    }
    return super.shouldParseExportDeclaration();
  }
  isExportDefaultSpecifier() {
    const {
      type
    } = this.state;
    if (tokenIsFlowInterfaceOrTypeOrOpaque(type) || this.shouldParseEnums() && type === 124) {
      return this.state.containsEsc;
    }
    return super.isExportDefaultSpecifier();
  }
  parseExportDefaultExpression() {
    if (this.shouldParseEnums() && this.isContextual(124)) {
      const node = this.startNode();
      this.next();
      return this.flowParseEnumDeclaration(node);
    }
    return super.parseExportDefaultExpression();
  }
  parseConditional(expr, 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(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, startLoc) {
    node = super.parseParenItem(node, startLoc);
    if (this.eat(17)) {
      node.optional = true;
      this.resetEndLocation(node);
    }
    if (this.match(14)) {
      const typeCastNode = this.startNodeAt(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);
  }
  parseExportDeclaration(node) {
    if (this.isContextual(128)) {
      node.exportKind = "type";
      const declarationNode = this.startNode();
      this.next();
      if (this.match(5)) {
        node.specifiers = this.parseExportSpecifiers(true);
        super.parseExportFrom(node);
        return null;
      } else {
        return this.flowParseTypeAlias(declarationNode);
      }
    } else if (this.isContextual(129)) {
      node.exportKind = "type";
      const declarationNode = this.startNode();
      this.next();
      return this.flowParseOpaqueType(declarationNode, false);
    } else if (this.isContextual(127)) {
      node.exportKind = "type";
      const declarationNode = this.startNode();
      this.next();
      return this.flowParseInterface(declarationNode);
    } else if (this.shouldParseEnums() && this.isContextual(124)) {
      node.exportKind = "value";
      const declarationNode = this.startNode();
      this.next();
      return this.flowParseEnumDeclaration(declarationNode);
    } else {
      return super.parseExportDeclaration(node);
    }
  }
  eatExportStar(node) {
    if (super.eatExportStar(node)) return true;
    if (this.isContextual(128) && 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(123)) {
      if (super.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, {
          at: 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(Errors.InvalidIdentifier, {
        at: this.state.curPosition(),
        identifierName: fullWord
      });
    }
    this.finishToken(130, fullWord);
  }
  getTokenFromCode(code) {
    const next = this.input.charCodeAt(this.state.pos + 1);
    if (code === 123 && next === 124) {
      this.finishOp(6, 2);
    } else if (this.state.inType && (code === 62 || code === 60)) {
      this.finishOp(code === 62 ? 48 : 47, 1);
    } else if (this.state.inType && code === 63) {
      if (next === 46) {
        this.finishOp(18, 2);
      } else {
        this.finishOp(17, 1);
      }
    } else if (isIteratorStart(code, next, this.input.charCodeAt(this.state.pos + 2))) {
      this.state.pos += 2;
      this.readIterator();
    } else {
      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 (!isLHS && node.type === "AssignmentExpression" && node.left.type === "TypeCastExpression") {
      node.left = this.typeCastToParameter(node.left);
    }
    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);
      }
    }
    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, {
          at: 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;
  }
  isValidLVal(type, isParenthesized, binding) {
    return type === "TypeCastExpression" || super.isValidLVal(type, isParenthesized, binding);
  }
  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, {
          at: 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, {
          at: 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(111)) {
      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, {
          at: param
        });
      } else if (this.isThisParam(param)) {
        this.raise(FlowErrors.SetterMayNotHaveThisParam, {
          at: param
        });
      }
    }
  }
  parsePropertyNamePrefixOperator(node) {
    node.variance = this.flowParseVariance();
  }
  parseObjPropValue(prop, 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();
    }
    const result = super.parseObjPropValue(prop, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors);
    if (typeParameters) {
      (result.value || result).typeParameters = typeParameters;
    }
    return result;
  }
  parseAssignableListItemTypes(param) {
    if (this.eat(17)) {
      if (param.type !== "Identifier") {
        this.raise(FlowErrors.PatternIsOptional, {
          at: param
        });
      }
      if (this.isThisParam(param)) {
        this.raise(FlowErrors.ThisParamMayNotBeOptional, {
          at: param
        });
      }
      param.optional = true;
    }
    if (this.match(14)) {
      param.typeAnnotation = this.flowParseTypeAnnotation();
    } else if (this.isThisParam(param)) {
      this.raise(FlowErrors.ThisParamAnnotationRequired, {
        at: param
      });
    }
    if (this.match(29) && this.isThisParam(param)) {
      this.raise(FlowErrors.ThisParamNoDefault, {
        at: param
      });
    }
    this.resetEndLocation(param);
    return param;
  }
  parseMaybeDefault(startLoc, left) {
    const node = super.parseMaybeDefault(startLoc, left);
    if (node.type === "AssignmentPattern" && node.typeAnnotation && node.right.start < node.typeAnnotation.start) {
      this.raise(FlowErrors.TypeBeforeInitializer, {
        at: node.typeAnnotation
      });
    }
    return node;
  }
  checkImportReflection(node) {
    super.checkImportReflection(node);
    if (node.module && node.importKind !== "value") {
      this.raise(FlowErrors.ImportReflectionHasImportType, {
        at: node.specifiers[0].loc.start
      });
    }
  }
  parseImportSpecifierLocal(node, specifier, type) {
    specifier.local = hasTypeImportKind(node) ? this.flowParseRestrictedIdentifier(true, true) : this.parseIdentifier();
    node.specifiers.push(this.finishImportSpecifier(specifier, type));
  }
  isPotentialImportPhase(isExport) {
    if (super.isPotentialImportPhase(isExport)) return true;
    if (this.isContextual(128)) {
      if (!isExport) return true;
      const ch = this.lookaheadCharCode();
      return ch === 123 || ch === 42;
    }
    return !isExport && this.isContextual(87);
  }
  applyImportPhase(node, isExport, phase, loc) {
    super.applyImportPhase(node, isExport, phase, loc);
    if (isExport) {
      if (!phase && this.match(65)) {
        return;
      }
      node.exportKind = phase === "type" ? phase : "value";
    } else {
      if (phase === "type" && this.match(55)) this.unexpected();
      node.importKind = phase === "type" || phase === "typeof" ? phase : "value";
    }
  }
  parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, bindingType) {
    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(Errors.ImportBindingIsString, {
            at: specifier,
            importName: 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, {
        at: 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);
    }
    return this.finishImportSpecifier(specifier, "ImportSpecifier");
  }
  parseBindingAtom() {
    switch (this.state.type) {
      case 78:
        return this.parseIdentifier(true);
      default:
        return super.parseBindingAtom();
    }
  }
  parseFunctionParams(node, isConstructor) {
    const kind = node.kind;
    if (kind !== "get" && kind !== "set" && this.match(47)) {
      node.typeParameters = this.flowParseTypeParameterDeclaration();
    }
    super.parseFunctionParams(node, isConstructor);
  }
  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(140) || 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, {
              at: 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, {
        at: 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, strictModeChanged = true) {
    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, {
          at: node.params[i]
        });
      }
    }
    super.checkParams(node, allowDuplicates, isArrowFunction, strictModeChanged);
  }
  parseParenAndDistinguishExpression(canBeArrow) {
    return super.parseParenAndDistinguishExpression(canBeArrow && this.state.noArrowAt.indexOf(this.state.start) === -1);
  }
  parseSubscripts(base, startLoc, noCalls) {
    if (base.type === "Identifier" && base.name === "async" && this.state.noArrowAt.indexOf(startLoc.index) !== -1) {
      this.next();
      const node = this.startNodeAt(startLoc);
      node.callee = base;
      node.arguments = super.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(startLoc) || abort(), state);
      if (!arrow.error && !arrow.aborted) return arrow.node;
      const result = this.tryParse(() => super.parseSubscripts(base, 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, startLoc, noCalls);
  }
  parseSubscript(base, 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(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(startLoc);
      node.callee = base;
      const result = this.tryParse(() => {
        node.typeArguments = this.flowParseTypeParameterInstantiationCallOrNew();
        this.expect(10);
        node.arguments = super.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, startLoc, noCalls, subscriptState);
  }
  parseNewCallee(node) {
    super.parseNewCallee(node);
    let targs = null;
    if (this.shouldParseTypes() && this.match(47)) {
      targs = this.tryParse(() => this.flowParseTypeParameterInstantiationCallOrNew()).node;
    }
    node.typeArguments = targs;
  }
  parseAsyncArrowWithTypeParameters(startLoc) {
    const node = this.startNodeAt(startLoc);
    this.parseFunctionParams(node, false);
    if (!this.parseArrow(node)) return;
    return super.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();
      const commentSkip = this.skipFlowComment();
      if (commentSkip) {
        this.state.pos += commentSkip;
        this.state.hasFlowComment = true;
      }
      return;
    }
    return super.skipBlockComment(this.state.hasFlowComment ? "*-/" : "*/");
  }
  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(Errors.UnterminatedComment, {
        at: this.state.curPosition()
      });
    }
  }
  flowEnumErrorBooleanMemberNotInitialized(loc, {
    enumName,
    memberName
  }) {
    this.raise(FlowErrors.EnumBooleanMemberNotInitialized, {
      at: loc,
      memberName,
      enumName
    });
  }
  flowEnumErrorInvalidMemberInitializer(loc, enumContext) {
    return this.raise(!enumContext.explicitType ? FlowErrors.EnumInvalidMemberInitializerUnknownType : enumContext.explicitType === "symbol" ? FlowErrors.EnumInvalidMemberInitializerSymbolType : FlowErrors.EnumInvalidMemberInitializerPrimaryType, Object.assign({
      at: loc
    }, enumContext));
  }
  flowEnumErrorNumberMemberNotInitialized(loc, {
    enumName,
    memberName
  }) {
    this.raise(FlowErrors.EnumNumberMemberNotInitialized, {
      at: loc,
      enumName,
      memberName
    });
  }
  flowEnumErrorStringMemberInconsistentlyInitailized(node, {
    enumName
  }) {
    this.raise(FlowErrors.EnumStringMemberInconsistentlyInitailized, {
      at: node,
      enumName
    });
  }
  flowEnumMemberInit() {
    const startLoc = this.state.startLoc;
    const endOfInit = () => this.match(12) || this.match(8);
    switch (this.state.type) {
      case 132:
        {
          const literal = this.parseNumericLiteral(this.state.value);
          if (endOfInit()) {
            return {
              type: "number",
              loc: literal.loc.start,
              value: literal
            };
          }
          return {
            type: "invalid",
            loc: startLoc
          };
        }
      case 131:
        {
          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, {
          at: id,
          memberName,
          suggestion: memberName[0].toUpperCase() + memberName.slice(1),
          enumName
        });
      }
      if (seenNames.has(memberName)) {
        this.raise(FlowErrors.EnumDuplicateMemberName, {
          at: 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)) return null;
    if (!tokenIsIdentifier(this.state.type)) {
      throw this.raise(FlowErrors.EnumInvalidExplicitTypeUnknownSupplied, {
        at: this.state.startLoc,
        enumName
      });
    }
    const {
      value
    } = this.state;
    this.next();
    if (value !== "boolean" && value !== "number" && value !== "string" && value !== "symbol") {
      this.raise(FlowErrors.EnumInvalidExplicitType, {
        at: this.state.startLoc,
        enumName,
        invalidEnumType: value
      });
    }
    return value;
  }
  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 = {
  __proto__: null,
  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 JsxErrors = ParseErrorEnum`jsx`({
  AttributeIsEmpty: "JSX attributes must only be assigned a non-empty expression.",
  MissingClosingTagElement: ({
    openingTagName
  }) => `Expected corresponding JSX closing tag for <${openingTagName}>.`,
  MissingClosingTagFragment: "Expected corresponding JSX closing tag for <>.",
  UnexpectedSequenceExpression: "Sequence expressions cannot be directly nested inside JSX. Did you mean to wrap it in parentheses (...)?",
  UnexpectedToken: ({
    unexpected,
    HTMLEntity
  }) => `Unexpected token \`${unexpected}\`. Did you mean \`${HTMLEntity}\` or \`{'${unexpected}'}\`?`,
  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 <>...</>?"
});
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 JSXParserMixin 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;
              this.finishToken(140);
            } else {
              super.getTokenFromCode(ch);
            }
            return;
          }
          out += this.input.slice(chunkStart, this.state.pos);
          this.finishToken(139, out);
          return;
        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(Errors.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++);
    this.finishToken(131, out);
  }
  jsxReadEntity() {
    const startPos = ++this.state.pos;
    if (this.codePointAtPos(this.state.pos) === 35) {
      ++this.state.pos;
      let radix = 10;
      if (this.codePointAtPos(this.state.pos) === 120) {
        radix = 16;
        ++this.state.pos;
      }
      const codePoint = this.readInt(radix, undefined, false, "bail");
      if (codePoint !== null && this.codePointAtPos(this.state.pos) === 59) {
        ++this.state.pos;
        return String.fromCodePoint(codePoint);
      }
    } else {
      let count = 0;
      let semi = false;
      while (count++ < 10 && this.state.pos < this.length && !(semi = this.codePointAtPos(this.state.pos) == 59)) {
        ++this.state.pos;
      }
      if (semi) {
        const desc = this.input.slice(startPos, this.state.pos);
        const entity = entities[desc];
        ++this.state.pos;
        if (entity) {
          return entity;
        }
      }
    }
    this.state.pos = startPos;
    return "&";
  }
  jsxReadWord() {
    let ch;
    const start = this.state.pos;
    do {
      ch = this.input.charCodeAt(++this.state.pos);
    } while (isIdentifierChar(ch) || ch === 45);
    this.finishToken(138, this.input.slice(start, this.state.pos));
  }
  jsxParseIdentifier() {
    const node = this.startNode();
    if (this.match(138)) {
      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 startLoc = this.state.startLoc;
    const name = this.jsxParseIdentifier();
    if (!this.eat(14)) return name;
    const node = this.startNodeAt(startLoc);
    node.namespace = name;
    node.name = this.jsxParseIdentifier();
    return this.finishNode(node, "JSXNamespacedName");
  }
  jsxParseElementName() {
    const startLoc = this.state.startLoc;
    let node = this.jsxParseNamespacedName();
    if (node.type === "JSXNamespacedName") {
      return node;
    }
    while (this.eat(16)) {
      const newNode = this.startNodeAt(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, {
            at: node
          });
        }
        return node;
      case 140:
      case 131:
        return this.parseExprAtom();
      default:
        throw this.raise(JsxErrors.UnsupportedJsxValue, {
          at: this.state.startLoc
        });
    }
  }
  jsxParseEmptyExpression() {
    const node = this.startNodeAt(this.state.lastTokEndLoc);
    return this.finishNodeAt(node, "JSXEmptyExpression", this.state.startLoc);
  }
  jsxParseSpreadChild(node) {
    this.next();
    node.expression = this.parseExpression();
    this.setContext(types.j_expr);
    this.state.canStartJSXElement = true;
    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.state.canStartJSXElement = true;
    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.state.canStartJSXElement = true;
      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(startLoc) {
    const node = this.startNodeAt(startLoc);
    if (this.eat(141)) {
      return this.finishNode(node, "JSXOpeningFragment");
    }
    node.name = this.jsxParseElementName();
    return this.jsxParseOpeningElementAfterName(node);
  }
  jsxParseOpeningElementAfterName(node) {
    const attributes = [];
    while (!this.match(56) && !this.match(141)) {
      attributes.push(this.jsxParseAttribute());
    }
    node.attributes = attributes;
    node.selfClosing = this.eat(56);
    this.expect(141);
    return this.finishNode(node, "JSXOpeningElement");
  }
  jsxParseClosingElementAt(startLoc) {
    const node = this.startNodeAt(startLoc);
    if (this.eat(141)) {
      return this.finishNode(node, "JSXClosingFragment");
    }
    node.name = this.jsxParseElementName();
    this.expect(141);
    return this.finishNode(node, "JSXClosingElement");
  }
  jsxParseElementAt(startLoc) {
    const node = this.startNodeAt(startLoc);
    const children = [];
    const openingElement = this.jsxParseOpeningElementAt(startLoc);
    let closingElement = null;
    if (!openingElement.selfClosing) {
      contents: for (;;) {
        switch (this.state.type) {
          case 140:
            startLoc = this.state.startLoc;
            this.next();
            if (this.eat(56)) {
              closingElement = this.jsxParseClosingElementAt(startLoc);
              break contents;
            }
            children.push(this.jsxParseElementAt(startLoc));
            break;
          case 139:
            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:
            this.unexpected();
        }
      }
      if (isFragment(openingElement) && !isFragment(closingElement) && closingElement !== null) {
        this.raise(JsxErrors.MissingClosingTagFragment, {
          at: closingElement
        });
      } else if (!isFragment(openingElement) && isFragment(closingElement)) {
        this.raise(JsxErrors.MissingClosingTagElement, {
          at: closingElement,
          openingTagName: getQualifiedJSXName(openingElement.name)
        });
      } else if (!isFragment(openingElement) && !isFragment(closingElement)) {
        if (getQualifiedJSXName(closingElement.name) !== getQualifiedJSXName(openingElement.name)) {
          this.raise(JsxErrors.MissingClosingTagElement, {
            at: closingElement,
            openingTagName: 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 startLoc = this.state.startLoc;
    this.next();
    return this.jsxParseElementAt(startLoc);
  }
  setContext(newContext) {
    const {
      context
    } = this.state;
    context[context.length - 1] = newContext;
  }
  parseExprAtom(refExpressionErrors) {
    if (this.match(139)) {
      return this.parseLiteral(this.state.value, "JSXText");
    } else if (this.match(140)) {
      return this.jsxParseElement();
    } else if (this.match(47) && this.input.charCodeAt(this.state.pos) !== 33) {
      this.replaceToken(140);
      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) {
      this.jsxReadToken();
      return;
    }
    if (context === types.j_oTag || context === types.j_cTag) {
      if (isIdentifierStart(code)) {
        this.jsxReadWord();
        return;
      }
      if (code === 62) {
        ++this.state.pos;
        this.finishToken(141);
        return;
      }
      if ((code === 34 || code === 39) && context === types.j_oTag) {
        this.jsxReadString(code);
        return;
      }
    }
    if (code === 60 && this.state.canStartJSXElement && this.input.charCodeAt(this.state.pos + 1) !== 33) {
      ++this.state.pos;
      this.finishToken(140);
      return;
    }
    super.getTokenFromCode(code);
  }
  updateContext(prevType) {
    const {
      context,
      type
    } = this.state;
    if (type === 56 && prevType === 140) {
      context.splice(-2, 2, types.j_cTag);
      this.state.canStartJSXElement = false;
    } else if (type === 140) {
      context.push(types.j_oTag);
    } else if (type === 141) {
      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 {
  constructor(...args) {
    super(...args);
    this.importsStack = [];
  }
  createScope(flags) {
    this.importsStack.push(new Set());
    return new TypeScriptScope(flags);
  }
  enter(flags) {
    if (flags == SCOPE_TS_MODULE) {
      this.importsStack.push(new Set());
    }
    super.enter(flags);
  }
  exit() {
    const flags = super.exit();
    if (flags == SCOPE_TS_MODULE) {
      this.importsStack.pop();
    }
    return flags;
  }
  hasImport(name, allowShadow) {
    const len = this.importsStack.length;
    if (this.importsStack[len - 1].has(name)) {
      return true;
    }
    if (!allowShadow && len > 1) {
      for (let i = 0; i < len - 1; i++) {
        if (this.importsStack[i].has(name)) return true;
      }
    }
    return false;
  }
  declareName(name, bindingType, loc) {
    if (bindingType & BIND_FLAGS_TS_IMPORT) {
      if (this.hasImport(name, true)) {
        this.parser.raise(Errors.VarRedeclaration, {
          at: loc,
          identifierName: name
        });
      }
      this.importsStack[this.importsStack.length - 1].add(name);
      return;
    }
    const scope = this.currentScope();
    if (bindingType & BIND_FLAGS_TS_EXPORT_ONLY) {
      this.maybeExportDefined(scope, name);
      scope.exportOnlyBindings.add(name);
      return;
    }
    super.declareName(name, bindingType, loc);
    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(scope, name, bindingType);
  }
  checkLocalExport(id) {
    const {
      name
    } = id;
    if (this.hasImport(name)) return;
    const len = this.scopeStack.length;
    for (let i = len - 1; i >= 0; i--) {
      const scope = this.scopeStack[i];
      if (scope.types.has(name) || scope.exportOnlyBindings.has(name)) return;
    }
    super.checkLocalExport(id);
  }
}
const getOwn$1 = (object, key) => Object.hasOwnProperty.call(object, key) && object[key];
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.recordArrowParameterBindingError(Errors.InvalidParenthesizedAssignment, {
            at: node
          });
        } else if (parenthesized.type !== "MemberExpression") {
          this.raise(Errors.InvalidParenthesizedAssignment, {
            at: node
          });
        }
      } else {
        this.raise(Errors.InvalidParenthesizedAssignment, {
          at: 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(Errors.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":
        {
          throw new Error("Internal @babel/parser error (this is a bug, please report it)." + " SpreadElement should be converted by .toAssignable's caller.");
        }
      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(Errors.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;
    }
  }
  toAssignableObjectExpressionProp(prop, isLast, isLHS) {
    if (prop.type === "ObjectMethod") {
      this.raise(prop.kind === "get" || prop.kind === "set" ? Errors.PatternHasAccessor : Errors.PatternHasMethod, {
        at: prop.key
      });
    } else if (prop.type === "SpreadElement") {
      prop.type = "RestElement";
      const arg = prop.argument;
      this.checkToRestConversion(arg, false);
      this.toAssignable(arg, isLHS);
      if (!isLast) {
        this.raise(Errors.RestTrailingComma, {
          at: prop
        });
      }
    } else {
      this.toAssignable(prop, isLHS);
    }
  }
  toAssignableList(exprList, trailingCommaLoc, isLHS) {
    const end = exprList.length - 1;
    for (let i = 0; i <= end; i++) {
      const elt = exprList[i];
      if (!elt) continue;
      if (elt.type === "SpreadElement") {
        elt.type = "RestElement";
        const arg = elt.argument;
        this.checkToRestConversion(arg, true);
        this.toAssignable(arg, isLHS);
      } else {
        this.toAssignable(elt, isLHS);
      }
      if (elt.type === "RestElement") {
        if (i < end) {
          this.raise(Errors.RestTrailingComma, {
            at: elt
          });
        } else if (trailingCommaLoc) {
          this.raise(Errors.RestTrailingComma, {
            at: trailingCommaLoc
          });
        }
      }
    }
  }
  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) {
    const node = this.startNode();
    this.next();
    node.argument = this.parseMaybeAssignAllowIn(refExpressionErrors, undefined);
    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, 1);
          return this.finishNode(node, "ArrayPattern");
        }
      case 5:
        return this.parseObjectLike(8, true);
    }
    return this.parseIdentifier();
  }
  parseBindingList(close, closeCharCode, flags) {
    const allowEmpty = flags & 1;
    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(), flags));
        if (!this.checkCommaAfterRest(closeCharCode)) {
          this.expect(close);
          break;
        }
      } else {
        const decorators = [];
        if (this.match(26) && this.hasPlugin("decorators")) {
          this.raise(Errors.UnsupportedParameterDecorator, {
            at: this.state.startLoc
          });
        }
        while (this.match(26)) {
          decorators.push(this.parseDecorator());
        }
        elts.push(this.parseAssignableListItem(flags, 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,
      startLoc
    } = this.state;
    if (type === 21) {
      return this.parseBindingRestProperty(prop);
    } else if (type === 136) {
      this.expectPlugin("destructuringPrivate", startLoc);
      this.classScope.usePrivateName(this.state.value, startLoc);
      prop.key = this.parsePrivateName();
    } else {
      this.parsePropertyName(prop);
    }
    prop.method = false;
    return this.parseObjPropValue(prop, startLoc, false, false, true, false);
  }
  parseAssignableListItem(flags, decorators) {
    const left = this.parseMaybeDefault();
    this.parseAssignableListItemTypes(left, flags);
    const elt = this.parseMaybeDefault(left.loc.start, left);
    if (decorators.length) {
      left.decorators = decorators;
    }
    return elt;
  }
  parseAssignableListItemTypes(param, flags) {
    return param;
  }
  parseMaybeDefault(startLoc, left) {
    var _startLoc, _left;
    (_startLoc = startLoc) != null ? _startLoc : startLoc = this.state.startLoc;
    left = (_left = left) != null ? _left : this.parseBindingAtom();
    if (!this.eat(29)) return left;
    const node = this.startNodeAt(startLoc);
    node.left = left;
    node.right = this.parseMaybeAssignAllowIn();
    return this.finishNode(node, "AssignmentPattern");
  }
  isValidLVal(type, isUnparenthesizedInAssign, binding) {
    return getOwn$1({
      AssignmentPattern: "left",
      RestElement: "argument",
      ObjectProperty: "value",
      ParenthesizedExpression: "expression",
      ArrayPattern: "elements",
      ObjectPattern: "properties"
    }, type);
  }
  checkLVal(expression, {
    in: ancestor,
    binding = BIND_NONE,
    checkClashes = false,
    strictModeChanged = false,
    hasParenthesizedAncestor = false
  }) {
    var _expression$extra;
    const type = expression.type;
    if (this.isObjectMethod(expression)) return;
    if (type === "MemberExpression") {
      if (binding !== BIND_NONE) {
        this.raise(Errors.InvalidPropertyBindingPattern, {
          at: expression
        });
      }
      return;
    }
    if (type === "Identifier") {
      this.checkIdentifier(expression, binding, strictModeChanged);
      const {
        name
      } = expression;
      if (checkClashes) {
        if (checkClashes.has(name)) {
          this.raise(Errors.ParamDupe, {
            at: expression
          });
        } else {
          checkClashes.add(name);
        }
      }
      return;
    }
    const validity = this.isValidLVal(type, !(hasParenthesizedAncestor || (_expression$extra = expression.extra) != null && _expression$extra.parenthesized) && ancestor.type === "AssignmentExpression", binding);
    if (validity === true) return;
    if (validity === false) {
      const ParseErrorClass = binding === BIND_NONE ? Errors.InvalidLhs : Errors.InvalidLhsBinding;
      this.raise(ParseErrorClass, {
        at: expression,
        ancestor
      });
      return;
    }
    const [key, isParenthesizedExpression] = Array.isArray(validity) ? validity : [validity, type === "ParenthesizedExpression"];
    const nextAncestor = type === "ArrayPattern" || type === "ObjectPattern" || type === "ParenthesizedExpression" ? {
      type
    } : ancestor;
    for (const child of [].concat(expression[key])) {
      if (child) {
        this.checkLVal(child, {
          in: nextAncestor,
          binding,
          checkClashes,
          strictModeChanged,
          hasParenthesizedAncestor: isParenthesizedExpression
        });
      }
    }
  }
  checkIdentifier(at, bindingType, strictModeChanged = false) {
    if (this.state.strict && (strictModeChanged ? isStrictBindReservedWord(at.name, this.inModule) : isStrictBindOnlyReservedWord(at.name))) {
      if (bindingType === BIND_NONE) {
        this.raise(Errors.StrictEvalArguments, {
          at,
          referenceName: at.name
        });
      } else {
        this.raise(Errors.StrictEvalArgumentsBinding, {
          at,
          bindingName: at.name
        });
      }
    }
    if (bindingType & BIND_FLAGS_NO_LET_IN_LEXICAL && at.name === "let") {
      this.raise(Errors.LetInLexicalBinding, {
        at
      });
    }
    if (!(bindingType & BIND_NONE)) {
      this.declareNameFromIdentifier(at, bindingType);
    }
  }
  declareNameFromIdentifier(identifier, binding) {
    this.scope.declareName(identifier.name, binding, identifier.loc.start);
  }
  checkToRestConversion(node, allowPattern) {
    switch (node.type) {
      case "ParenthesizedExpression":
        this.checkToRestConversion(node.expression, allowPattern);
        break;
      case "Identifier":
      case "MemberExpression":
        break;
      case "ArrayExpression":
      case "ObjectExpression":
        if (allowPattern) break;
      default:
        this.raise(Errors.InvalidRestAssignmentPattern, {
          at: node
        });
    }
  }
  checkCommaAfterRest(close) {
    if (!this.match(12)) {
      return false;
    }
    this.raise(this.lookaheadCharCode() === close ? Errors.RestTrailingComma : Errors.ElementAfterRest, {
      at: this.state.startLoc
    });
    return true;
  }
}
const getOwn = (object, key) => Object.hasOwnProperty.call(object, key) && object[key];
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 = ParseErrorEnum`typescript`({
  AbstractMethodHasImplementation: ({
    methodName
  }) => `Method '${methodName}' cannot have an implementation because it is marked abstract.`,
  AbstractPropertyHasInitializer: ({
    propertyName
  }) => `Property '${propertyName}' 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.",
  AccessorCannotBeOptional: "An 'accessor' property cannot be declared optional.",
  ClassMethodHasDeclare: "Class methods cannot have the 'declare' modifier.",
  ClassMethodHasReadonly: "Class methods cannot have the 'readonly' modifier.",
  ConstInitiailizerMustBeStringOrNumericLiteralOrLiteralEnumReference: "A 'const' initializer in an ambient context must be a string or numeric literal or literal enum reference.",
  ConstructorHasTypeParameters: "Type parameters cannot appear on a constructor declaration.",
  DeclareAccessor: ({
    kind
  }) => `'declare' is not allowed in ${kind}ters.`,
  DeclareClassFieldHasInitializer: "Initializers are not allowed in ambient contexts.",
  DeclareFunctionHasImplementation: "An implementation cannot be declared in ambient contexts.",
  DuplicateAccessibilityModifier: ({
    modifier
  }) => `Accessibility modifier already seen.`,
  DuplicateModifier: ({
    modifier
  }) => `Duplicate modifier: '${modifier}'.`,
  EmptyHeritageClauseType: ({
    token
  }) => `'${token}' 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'.",
  ImportReflectionHasImportType: "An `import module` declaration can not use `type` modifier",
  IncompatibleModifiers: ({
    modifiers
  }) => `'${modifiers[0]}' modifier cannot be used with '${modifiers[1]}' modifier.`,
  IndexSignatureHasAbstract: "Index signatures cannot have the 'abstract' modifier.",
  IndexSignatureHasAccessibility: ({
    modifier
  }) => `Index signatures cannot have an accessibility modifier ('${modifier}').`,
  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.",
  InitializerNotAllowedInAmbientContext: "Initializers are not allowed in ambient contexts.",
  InvalidModifierOnTypeMember: ({
    modifier
  }) => `'${modifier}' modifier cannot appear on a type member.`,
  InvalidModifierOnTypeParameter: ({
    modifier
  }) => `'${modifier}' modifier cannot appear on a type parameter.`,
  InvalidModifierOnTypeParameterPositions: ({
    modifier
  }) => `'${modifier}' modifier can only appear on a type parameter of a class, interface or type alias.`,
  InvalidModifiersOrder: ({
    orderedModifiers
  }) => `'${orderedModifiers[0]}' modifier must precede '${orderedModifiers[1]}' modifier.`,
  InvalidPropertyAccessAfterInstantiationExpression: "Invalid property access after an instantiation expression. " + "You can either wrap the instantiation expression in parentheses, or delete the type arguments.",
  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: ({
    modifier
  }) => `Private elements cannot have an accessibility modifier ('${modifier}').`,
  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 `<T,>() => ...`.",
  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.",
  SingleTypeParameterWithoutTrailingComma: ({
    typeParameterName
  }) => `Single type parameter ${typeParameterName} should have a trailing comma. Example usage: <${typeParameterName},>.`,
  StaticBlockCannotHaveModifier: "Static class blocks cannot have any modifier.",
  TupleOptionalAfterType: "A labeled tuple optional element must be declared using a question mark after the name and before the colon (`name?: type`), rather than after the type (`name: type?`).",
  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: ({
    type
  }) => `Name in a signature must be an Identifier, ObjectPattern or ArrayPattern, instead got ${type}.`
});
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";
}
function tsIsVarianceAnnotations(modifier) {
  return modifier === "in" || modifier === "out";
}
var typescript = superClass => class TypeScriptParserMixin extends superClass {
  constructor(...args) {
    super(...args);
    this.tsParseInOutModifiers = this.tsParseModifiers.bind(this, {
      allowedModifiers: ["in", "out"],
      disallowedModifiers: ["const", "public", "private", "protected", "readonly", "declare", "abstract", "override"],
      errorTemplate: TSErrors.InvalidModifierOnTypeParameter
    });
    this.tsParseConstModifier = this.tsParseModifiers.bind(this, {
      allowedModifiers: ["const"],
      disallowedModifiers: ["in", "out"],
      errorTemplate: TSErrors.InvalidModifierOnTypeParameterPositions
    });
    this.tsParseInOutConstModifiers = this.tsParseModifiers.bind(this, {
      allowedModifiers: ["in", "out", "const"],
      disallowedModifiers: ["public", "private", "protected", "readonly", "declare", "abstract", "override"],
      errorTemplate: TSErrors.InvalidModifierOnTypeParameter
    });
  }
  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(136) || this.isLiteralPropertyName()) && !this.hasPrecedingLineBreak();
  }
  tsNextTokenCanFollowModifier() {
    this.next();
    return this.tsTokenCanFollowModifier();
  }
  tsParseModifier(allowedModifiers, stopOnStartOfClassStaticBlock) {
    if (!tokenIsIdentifier(this.state.type) && this.state.type !== 58 && this.state.type !== 75) {
      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({
    allowedModifiers,
    disallowedModifiers,
    stopOnStartOfClassStaticBlock,
    errorTemplate = TSErrors.InvalidModifierOnTypeMember
  }, modified) {
    const enforceOrder = (loc, modifier, before, after) => {
      if (modifier === before && modified[after]) {
        this.raise(TSErrors.InvalidModifiersOrder, {
          at: loc,
          orderedModifiers: [before, after]
        });
      }
    };
    const incompatible = (loc, modifier, mod1, mod2) => {
      if (modified[mod1] && modifier === mod2 || modified[mod2] && modifier === mod1) {
        this.raise(TSErrors.IncompatibleModifiers, {
          at: loc,
          modifiers: [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,
            modifier
          });
        } else {
          enforceOrder(startLoc, modifier, modifier, "override");
          enforceOrder(startLoc, modifier, modifier, "static");
          enforceOrder(startLoc, modifier, modifier, "readonly");
          modified.accessibility = modifier;
        }
      } else if (tsIsVarianceAnnotations(modifier)) {
        if (modified[modifier]) {
          this.raise(TSErrors.DuplicateModifier, {
            at: startLoc,
            modifier
          });
        }
        modified[modifier] = true;
        enforceOrder(startLoc, modifier, "in", "out");
      } 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);
    }
  }
  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(131)) {
      this.raise(TSErrors.UnsupportedImportTypeArgument, {
        at: this.state.startLoc
      });
    }
    node.argument = super.parseExprAtom();
    this.expect(11);
    if (this.eat(16)) {
      node.qualifier = this.tsParseEntityName();
    }
    if (this.match(47)) {
      node.typeParameters = this.tsParseTypeArguments();
    }
    return this.finishNode(node, "TSImportType");
  }
  tsParseEntityName(allowReservedWords = true) {
    let entity = this.parseIdentifier(allowReservedWords);
    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();
    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();
    }
    if (!this.hasPrecedingLineBreak() && this.match(47)) {
      node.typeParameters = this.tsParseTypeArguments();
    }
    return this.finishNode(node, "TSTypeQuery");
  }
  tsParseTypeParameter(parseModifiers) {
    const node = this.startNode();
    parseModifiers(node);
    node.name = this.tsParseTypeParameterName();
    node.constraint = this.tsEatThenParseType(81);
    node.default = this.tsEatThenParseType(29);
    return this.finishNode(node, "TSTypeParameter");
  }
  tsTryParseTypeParameters(parseModifiers) {
    if (this.match(47)) {
      return this.tsParseTypeParameters(parseModifiers);
    }
  }
  tsParseTypeParameters(parseModifiers) {
    const node = this.startNode();
    if (this.match(47) || this.match(140)) {
      this.next();
    } else {
      this.unexpected();
    }
    const refTrailingCommaPos = {
      value: -1
    };
    node.params = this.tsParseBracketedList("TypeParametersOrArguments", this.tsParseTypeParameter.bind(this, parseModifiers), false, true, refTrailingCommaPos);
    if (node.params.length === 0) {
      this.raise(TSErrors.EmptyTypeParameters, {
        at: node
      });
    }
    if (refTrailingCommaPos.value !== -1) {
      this.addExtra(node, "trailingComma", refTrailingCommaPos.value);
    }
    return this.finishNode(node, "TSTypeParameterDeclaration");
  }
  tsFillSignature(returnToken, signature) {
    const returnTokenRequired = returnToken === 19;
    const paramsKey = "parameters";
    const returnTypeKey = "typeAnnotation";
    signature.typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier);
    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() {
    const list = super.parseBindingList(11, 41, 2);
    for (const pattern of list) {
      const {
        type
      } = pattern;
      if (type === "AssignmentPattern" || type === "TSParameterProperty") {
        this.raise(TSErrors.UnsupportedSignatureParameterKind, {
          at: pattern,
          type
        });
      }
    }
    return list;
  }
  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;
    }
    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, {
          at: 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(Errors.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(Errors.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, {
            at: 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({
      allowedModifiers: ["readonly"],
      disallowedModifiers: ["declare", "abstract", "private", "protected", "public", "static", "override"]
    }, node);
    const idx = this.tsTryParseIndexSignature(node);
    if (idx) {
      return idx;
    }
    super.parsePropertyName(node);
    if (!node.computed && node.key.type === "Identifier" && (node.key.name === "get" || node.key.name === "set") && this.tsTokenCanFollowModifier()) {
      node.kind = node.key.name;
      super.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(120);
    }
    if (this.isContextual(120)) {
      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(120);
    } else if (this.eatContextual(120)) {
      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;
      const {
        type
      } = elementNode;
      if (seenOptionalElement && type !== "TSRestType" && type !== "TSOptionalType" && !(type === "TSNamedTupleMember" && elementNode.optional)) {
        this.raise(TSErrors.OptionalTypeBeforeRequired, {
          at: elementNode
        });
      }
      seenOptionalElement || (seenOptionalElement = type === "TSNamedTupleMember" && elementNode.optional || type === "TSOptionalType");
      let checkType = type;
      if (type === "TSRestType") {
        elementNode = elementNode.typeAnnotation;
        checkType = elementNode.type;
      }
      const isLabeled = checkType === "TSNamedTupleMember";
      (_labeledElements = labeledElements) != null ? _labeledElements : labeledElements = isLabeled;
      if (labeledElements !== isLabeled) {
        this.raise(TSErrors.MixedLabeledAndUnlabeledElements, {
          at: elementNode
        });
      }
    });
    return this.finishNode(node, "TSTupleType");
  }
  tsParseTupleElementType() {
    const {
      startLoc
    } = this.state;
    const rest = this.eat(21);
    let labeled;
    let label;
    let optional;
    let type;
    const isWord = tokenIsKeywordOrIdentifier(this.state.type);
    const chAfterWord = isWord ? this.lookaheadCharCode() : null;
    if (chAfterWord === 58) {
      labeled = true;
      optional = false;
      label = this.parseIdentifier(true);
      this.expect(14);
      type = this.tsParseType();
    } else if (chAfterWord === 63) {
      optional = true;
      const startLoc = this.state.startLoc;
      const wordName = this.state.value;
      const typeOrLabel = this.tsParseNonArrayType();
      if (this.lookaheadCharCode() === 58) {
        labeled = true;
        label = this.createIdentifier(this.startNodeAt(startLoc), wordName);
        this.expect(17);
        this.expect(14);
        type = this.tsParseType();
      } else {
        labeled = false;
        type = typeOrLabel;
        this.expect(17);
      }
    } else {
      type = this.tsParseType();
      optional = this.eat(17);
      labeled = this.eat(14);
    }
    if (labeled) {
      let labeledNode;
      if (label) {
        labeledNode = this.startNodeAtNode(label);
        labeledNode.optional = optional;
        labeledNode.label = label;
        labeledNode.elementType = type;
        if (this.eat(17)) {
          labeledNode.optional = true;
          this.raise(TSErrors.TupleOptionalAfterType, {
            at: this.state.lastTokStartLoc
          });
        }
      } else {
        labeledNode = this.startNodeAtNode(type);
        labeledNode.optional = optional;
        this.raise(TSErrors.InvalidTupleMemberLabel, {
          at: 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(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.tsInAllowConditionalTypesContext(() => this.tsFillSignature(19, node));
    return this.finishNode(node, type);
  }
  tsParseLiteralTypeNode() {
    const node = this.startNode();
    switch (this.state.type) {
      case 132:
      case 133:
      case 131:
      case 85:
      case 86:
        node.literal = super.parseExprAtom();
        break;
      default:
        this.unexpected();
    }
    return this.finishNode(node, "TSLiteralType");
  }
  tsParseTemplateLiteralType() {
    const node = this.startNode();
    node.literal = super.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(114) && !this.hasPrecedingLineBreak()) {
      return this.tsParseThisTypePredicate(thisKeyword);
    } else {
      return thisKeyword;
    }
  }
  tsParseNonArrayType() {
    switch (this.state.type) {
      case 131:
      case 132:
      case 133:
      case 85:
      case 86:
        return this.tsParseLiteralTypeNode();
      case 53:
        if (this.state.value === "-") {
          const node = this.startNode();
          const nextToken = this.lookahead();
          if (nextToken.type !== 132 && nextToken.type !== 133) {
            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();
          }
        }
    }
    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, {
          at: node
        });
    }
  }
  tsParseInferType() {
    const node = this.startNode();
    this.expectContextual(113);
    const typeParameter = this.startNode();
    typeParameter.name = this.tsParseTypeParameterName();
    typeParameter.constraint = this.tsTryParse(() => this.tsParseConstraintForInferType());
    node.typeParameter = this.finishNode(typeParameter, "TSTypeParameter");
    return this.finishNode(node, "TSInferType");
  }
  tsParseConstraintForInferType() {
    if (this.eat(81)) {
      const constraint = this.tsInDisallowConditionalTypesContext(() => this.tsParseType());
      if (this.state.inDisallowConditionalTypesContext || !this.match(17)) {
        return constraint;
      }
    }
  }
  tsParseTypeOperatorOrHigher() {
    const isTypeOperator = tokenIsTSTypeOperator(this.state.type) && !this.state.containsEsc;
    return isTypeOperator ? this.tsParseTypeOperator() : this.isContextual(113) ? this.tsParseInferType() : this.tsInAllowConditionalTypesContext(() => 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)) {
      const {
        errors
      } = this.state;
      const previousErrorCount = errors.length;
      try {
        this.parseObjectLike(8, true);
        return errors.length === previousErrorCount;
      } catch (_unused) {
        return false;
      }
    }
    if (this.match(0)) {
      this.next();
      const {
        errors
      } = this.state;
      const previousErrorCount = errors.length;
      try {
        super.parseBindingList(3, 93, 1);
        return errors.length === previousErrorCount;
      } catch (_unused2) {
        return false;
      }
    }
    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() {
    if (this.match(14)) {
      return this.tsParseTypeOrTypePredicateAnnotation(14);
    }
  }
  tsTryParseTypeAnnotation() {
    if (this.match(14)) {
      return this.tsParseTypeAnnotation();
    }
  }
  tsTryParseType() {
    return this.tsEatThenParseType(14);
  }
  tsParseTypePredicatePrefix() {
    const id = this.parseIdentifier();
    if (this.isContextual(114) && !this.hasPrecedingLineBreak()) {
      this.next();
      return id;
    }
  }
  tsParseTypePredicateAsserts() {
    if (this.state.type !== 107) {
      return false;
    }
    const containsEsc = this.state.containsEsc;
    this.next();
    if (!tokenIsIdentifier(this.state.type) && !this.match(78)) {
      return false;
    }
    if (containsEsc) {
      this.raise(Errors.InvalidEscapedReservedWord, {
        at: this.state.lastTokStartLoc,
        reservedWord: "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.state.inDisallowConditionalTypesContext || this.hasPrecedingLineBreak() || !this.eat(81)) {
      return type;
    }
    const node = this.startNodeAtNode(type);
    node.checkType = type;
    node.extendsType = this.tsInDisallowConditionalTypesContext(() => this.tsParseNonConditionalType());
    this.expect(17);
    node.trueType = this.tsInAllowConditionalTypesContext(() => this.tsParseType());
    this.expect(14);
    node.falseType = this.tsInAllowConditionalTypesContext(() => this.tsParseType());
    return this.finishNode(node, "TSConditionalType");
  }
  isAbstractConstructorSignature() {
    return this.isContextual(122) && 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();
    node.typeAnnotation = this.tsInType(() => {
      this.next();
      return this.match(75) ? this.tsParseTypeReference() : this.tsParseType();
    });
    this.expect(48);
    node.expression = this.parseMaybeUnary();
    return this.finishNode(node, "TSTypeAssertion");
  }
  tsParseHeritageClause(token) {
    const originalStartLoc = this.state.startLoc;
    const delimitedList = this.tsParseDelimitedList("HeritageClauseElement", () => {
      const node = this.startNode();
      node.expression = this.tsParseEntityName();
      if (this.match(47)) {
        node.typeParameters = this.tsParseTypeArguments();
      }
      return this.finishNode(node, "TSExpressionWithTypeArguments");
    });
    if (!delimitedList.length) {
      this.raise(TSErrors.EmptyHeritageClauseType, {
        at: originalStartLoc,
        token
      });
    }
    return delimitedList;
  }
  tsParseInterfaceDeclaration(node, properties = {}) {
    if (this.hasFollowingLineBreak()) return null;
    this.expectContextual(127);
    if (properties.declare) node.declare = true;
    if (tokenIsIdentifier(this.state.type)) {
      node.id = this.parseIdentifier();
      this.checkIdentifier(node.id, BIND_TS_INTERFACE);
    } else {
      node.id = null;
      this.raise(TSErrors.MissingInterfaceName, {
        at: this.state.startLoc
      });
    }
    node.typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutConstModifiers);
    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.checkIdentifier(node.id, BIND_TS_TYPE);
    node.typeAnnotation = this.tsInType(() => {
      node.typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutModifiers);
      this.expect(29);
      if (this.isContextual(112) && 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;
    }
  }
  tsInDisallowConditionalTypesContext(cb) {
    const oldInDisallowConditionalTypesContext = this.state.inDisallowConditionalTypesContext;
    this.state.inDisallowConditionalTypesContext = true;
    try {
      return cb();
    } finally {
      this.state.inDisallowConditionalTypesContext = oldInDisallowConditionalTypesContext;
    }
  }
  tsInAllowConditionalTypesContext(cb) {
    const oldInDisallowConditionalTypesContext = this.state.inDisallowConditionalTypesContext;
    this.state.inDisallowConditionalTypesContext = false;
    try {
      return cb();
    } finally {
      this.state.inDisallowConditionalTypesContext = oldInDisallowConditionalTypesContext;
    }
  }
  tsEatThenParseType(token) {
    if (this.match(token)) {
      return this.tsNextThenParseType();
    }
  }
  tsExpectThenParseType(token) {
    return this.tsInType(() => {
      this.expect(token);
      return this.tsParseType();
    });
  }
  tsNextThenParseType() {
    return this.tsInType(() => {
      this.next();
      return this.tsParseType();
    });
  }
  tsParseEnumMember() {
    const node = this.startNode();
    node.id = this.match(131) ? super.parseStringLiteral(this.state.value) : this.parseIdentifier(true);
    if (this.eat(29)) {
      node.initializer = super.parseMaybeAssignAllowIn();
    }
    return this.finishNode(node, "TSEnumMember");
  }
  tsParseEnumDeclaration(node, properties = {}) {
    if (properties.const) node.const = true;
    if (properties.declare) node.declare = true;
    this.expectContextual(124);
    node.id = this.parseIdentifier();
    this.checkIdentifier(node.id, node.const ? 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);
    super.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.checkIdentifier(node.id, 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(110)) {
      node.global = true;
      node.id = this.parseIdentifier();
    } else if (this.match(131)) {
      node.id = super.parseStringLiteral(this.state.value);
    } 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, maybeDefaultIdentifier, isExport) {
    node.isExport = isExport || false;
    node.id = maybeDefaultIdentifier || this.parseIdentifier();
    this.checkIdentifier(node.id, BIND_FLAGS_TS_IMPORT);
    this.expect(29);
    const moduleReference = this.tsParseModuleReference();
    if (node.importKind === "type" && moduleReference.type !== "TSExternalModuleReference") {
      this.raise(TSErrors.ImportAliasHasImportType, {
        at: moduleReference
      });
    }
    node.moduleReference = moduleReference;
    this.semicolon();
    return this.finishNode(node, "TSImportEqualsDeclaration");
  }
  tsIsExternalModuleReference() {
    return this.isContextual(117) && this.lookaheadCharCode() === 40;
  }
  tsParseModuleReference() {
    return this.tsIsExternalModuleReference() ? this.tsParseExternalModuleReference() : this.tsParseEntityName(false);
  }
  tsParseExternalModuleReference() {
    const node = this.startNode();
    this.expectContextual(117);
    this.expect(10);
    if (!this.match(131)) {
      this.unexpected();
    }
    node.expression = super.parseExprAtom();
    this.expect(11);
    this.sawUnambiguousESM = true;
    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;
    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;
    }
    this.state = state;
  }
  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 super.parseFunctionStatement(nany, false, false);
        case 80:
          nany.declare = true;
          return this.parseClass(nany, true, false);
        case 124:
          return this.tsParseEnumDeclaration(nany, {
            declare: true
          });
        case 110:
          return this.tsParseAmbientExternalModuleDeclaration(nany);
        case 75:
        case 74:
          if (!this.match(75) || !this.isLookaheadContextual("enum")) {
            nany.declare = true;
            return this.parseVarStatement(nany, kind || this.state.value, true);
          }
          this.expect(75);
          return this.tsParseEnumDeclaration(nany, {
            const: true,
            declare: true
          });
        case 127:
          {
            const result = this.tsParseInterfaceDeclaration(nany, {
              declare: true
            });
            if (result) return result;
          }
        default:
          if (tokenIsIdentifier(startType)) {
            return this.tsParseDeclaration(nany, this.state.value, true, null);
          }
      }
    });
  }
  tsTryParseExportDeclaration() {
    return this.tsParseDeclaration(this.startNode(), this.state.value, true, null);
  }
  tsParseExpressionStatement(node, expr, decorators) {
    switch (expr.name) {
      case "declare":
        {
          const declaration = this.tsTryParseDeclare(node);
          if (declaration) {
            declaration.declare = true;
          }
          return declaration;
        }
      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, decorators);
    }
  }
  tsParseDeclaration(node, value, next, decorators) {
    switch (value) {
      case "abstract":
        if (this.tsCheckLineTerminator(next) && (this.match(80) || tokenIsIdentifier(this.state.type))) {
          return this.tsParseAbstractDeclaration(node, decorators);
        }
        break;
      case "module":
        if (this.tsCheckLineTerminator(next)) {
          if (this.match(131)) {
            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(startLoc) {
    if (!this.match(47)) return;
    const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;
    this.state.maybeInArrowParameters = true;
    const res = this.tsTryParseAndCatch(() => {
      const node = this.startNodeAt(startLoc);
      node.typeParameters = this.tsParseTypeParameters(this.tsParseConstModifier);
      super.parseFunctionParams(node);
      node.returnType = this.tsTryParseTypeOrTypePredicateAnnotation();
      this.expect(19);
      return node;
    });
    this.state.maybeInArrowParameters = oldMaybeInArrowParameters;
    if (!res) return;
    return super.parseArrowExpression(res, null, true);
  }
  tsParseTypeArgumentsInExpression() {
    if (this.reScan_lt() !== 47) return;
    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, {
        at: node
      });
    } else if (!this.state.inType && this.curContext() === types.brace) {
      this.reScan_lt_gt();
    }
    this.expect(48);
    return this.finishNode(node, "TSTypeParameterInstantiation");
  }
  tsIsDeclarationStart() {
    return tokenIsTSDeclarationStart(this.state.type);
  }
  isExportDefaultSpecifier() {
    if (this.tsIsDeclarationStart()) return false;
    return super.isExportDefaultSpecifier();
  }
  parseAssignableListItem(flags, decorators) {
    const startLoc = this.state.startLoc;
    const modified = {};
    this.tsParseModifiers({
      allowedModifiers: ["public", "private", "protected", "override", "readonly"]
    }, modified);
    const accessibility = modified.accessibility;
    const override = modified.override;
    const readonly = modified.readonly;
    if (!(flags & 4) && (accessibility || readonly || override)) {
      this.raise(TSErrors.UnexpectedParameterModifier, {
        at: startLoc
      });
    }
    const left = this.parseMaybeDefault();
    this.parseAssignableListItemTypes(left, flags);
    const elt = this.parseMaybeDefault(left.loc.start, left);
    if (accessibility || readonly || override) {
      const pp = this.startNodeAt(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, {
          at: pp
        });
      }
      pp.parameter = elt;
      return this.finishNode(pp, "TSParameterProperty");
    }
    if (decorators.length) {
      left.decorators = decorators;
    }
    return elt;
  }
  isSimpleParameter(node) {
    return node.type === "TSParameterProperty" && super.isSimpleParameter(node.parameter) || super.isSimpleParameter(node);
  }
  tsDisallowOptionalPattern(node) {
    for (const param of node.params) {
      if (param.type !== "Identifier" && param.optional && !this.state.isAmbientContext) {
        this.raise(TSErrors.PatternIsOptional, {
          at: param
        });
      }
    }
  }
  setArrowFunctionParameters(node, params, trailingCommaLoc) {
    super.setArrowFunctionParameters(node, params, trailingCommaLoc);
    this.tsDisallowOptionalPattern(node);
  }
  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()) {
      return this.finishNode(node, bodilessType);
    }
    if (bodilessType === "TSDeclareFunction" && this.state.isAmbientContext) {
      this.raise(TSErrors.DeclareFunctionHasImplementation, {
        at: node
      });
      if (node.declare) {
        return super.parseFunctionBodyAndFinish(node, bodilessType, isMethod);
      }
    }
    this.tsDisallowOptionalPattern(node);
    return super.parseFunctionBodyAndFinish(node, type, isMethod);
  }
  registerFunctionStatementId(node) {
    if (!node.body && node.id) {
      this.checkIdentifier(node.id, BIND_TS_AMBIENT);
    } else {
      super.registerFunctionStatementId(node);
    }
  }
  tsCheckForInvalidTypeCasts(items) {
    items.forEach(node => {
      if ((node == null ? void 0 : node.type) === "TSTypeCastExpression") {
        this.raise(TSErrors.UnexpectedTypeAnnotation, {
          at: node.typeAnnotation
        });
      }
    });
  }
  toReferencedList(exprList, isInParens) {
    this.tsCheckForInvalidTypeCasts(exprList);
    return exprList;
  }
  parseArrayLike(close, canBePattern, isTuple, refExpressionErrors) {
    const node = super.parseArrayLike(close, canBePattern, isTuple, refExpressionErrors);
    if (node.type === "ArrayExpression") {
      this.tsCheckForInvalidTypeCasts(node.elements);
    }
    return node;
  }
  parseSubscript(base, startLoc, noCalls, state) {
    if (!this.hasPrecedingLineBreak() && this.match(35)) {
      this.state.canStartJSXElement = false;
      this.next();
      const nonNullExpression = this.startNodeAt(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(startLoc);
          if (asyncArrowFn) {
            return asyncArrowFn;
          }
        }
        const typeArguments = this.tsParseTypeArgumentsInExpression();
        if (!typeArguments) return;
        if (isOptionalCall && !this.match(10)) {
          missingParenErrorLoc = this.state.curPosition();
          return;
        }
        if (tokenIsTemplate(this.state.type)) {
          const result = super.parseTaggedTemplateExpression(base, startLoc, state);
          result.typeParameters = typeArguments;
          return result;
        }
        if (!noCalls && this.eat(10)) {
          const node = this.startNodeAt(startLoc);
          node.callee = base;
          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);
        }
        const tokenType = this.state.type;
        if (tokenType === 48 || tokenType === 52 || tokenType !== 10 && tokenCanStartExpression(tokenType) && !this.hasPrecedingLineBreak()) {
          return;
        }
        const node = this.startNodeAt(startLoc);
        node.expression = base;
        node.typeParameters = typeArguments;
        return this.finishNode(node, "TSInstantiationExpression");
      });
      if (missingParenErrorLoc) {
        this.unexpected(missingParenErrorLoc, 10);
      }
      if (result) {
        if (result.type === "TSInstantiationExpression" && (this.match(16) || this.match(18) && this.lookaheadCharCode() !== 40)) {
          this.raise(TSErrors.InvalidPropertyAccessAfterInstantiationExpression, {
            at: this.state.startLoc
          });
        }
        return result;
      }
    }
    return super.parseSubscript(base, startLoc, noCalls, state);
  }
  parseNewCallee(node) {
    var _callee$extra;
    super.parseNewCallee(node);
    const {
      callee
    } = node;
    if (callee.type === "TSInstantiationExpression" && !((_callee$extra = callee.extra) != null && _callee$extra.parenthesized)) {
      node.typeParameters = callee.typeParameters;
      node.callee = callee.expression;
    }
  }
  parseExprOp(left, leftStartLoc, minPrec) {
    let isSatisfies;
    if (tokenOperatorPrecedence(58) > minPrec && !this.hasPrecedingLineBreak() && (this.isContextual(93) || (isSatisfies = this.isContextual(118)))) {
      const node = this.startNodeAt(leftStartLoc);
      node.expression = left;
      node.typeAnnotation = this.tsInType(() => {
        this.next();
        if (this.match(75)) {
          if (isSatisfies) {
            this.raise(Errors.UnexpectedKeyword, {
              at: this.state.startLoc,
              keyword: "const"
            });
          }
          return this.tsParseTypeReference();
        }
        return this.tsParseType();
      });
      this.finishNode(node, isSatisfies ? "TSSatisfiesExpression" : "TSAsExpression");
      this.reScan_lt_gt();
      return this.parseExprOp(node, leftStartLoc, minPrec);
    }
    return super.parseExprOp(left, leftStartLoc, minPrec);
  }
  checkReservedWord(word, startLoc, checkKeywords, isBinding) {
    if (!this.state.isAmbientContext) {
      super.checkReservedWord(word, startLoc, checkKeywords, isBinding);
    }
  }
  checkImportReflection(node) {
    super.checkImportReflection(node);
    if (node.module && node.importKind !== "value") {
      this.raise(TSErrors.ImportReflectionHasImportType, {
        at: node.specifiers[0].loc.start
      });
    }
  }
  checkDuplicateExports() {}
  isPotentialImportPhase(isExport) {
    if (super.isPotentialImportPhase(isExport)) return true;
    if (this.isContextual(128)) {
      const ch = this.lookaheadCharCode();
      return isExport ? ch === 123 || ch === 42 : ch !== 61;
    }
    return !isExport && this.isContextual(87);
  }
  applyImportPhase(node, isExport, phase, loc) {
    super.applyImportPhase(node, isExport, phase, loc);
    if (isExport) {
      node.exportKind = phase === "type" ? "type" : "value";
    } else {
      node.importKind = phase === "type" || phase === "typeof" ? phase : "value";
    }
  }
  parseImport(node) {
    if (this.match(131)) {
      node.importKind = "value";
      return super.parseImport(node);
    }
    let importNode;
    if (tokenIsIdentifier(this.state.type) && this.lookaheadCharCode() === 61) {
      node.importKind = "value";
      return this.tsParseImportEqualsDeclaration(node);
    } else if (this.isContextual(128)) {
      const maybeDefaultIdentifier = this.parseMaybeImportPhase(node, false);
      if (this.lookaheadCharCode() === 61) {
        return this.tsParseImportEqualsDeclaration(node, maybeDefaultIdentifier);
      } else {
        importNode = super.parseImportSpecifiersAndAfter(node, maybeDefaultIdentifier);
      }
    } else {
      importNode = super.parseImport(node);
    }
    if (importNode.importKind === "type" && importNode.specifiers.length > 1 && importNode.specifiers[0].type === "ImportDefaultSpecifier") {
      this.raise(TSErrors.TypeImportCannotSpecifyDefaultAndNamed, {
        at: importNode
      });
    }
    return importNode;
  }
  parseExport(node, decorators) {
    if (this.match(83)) {
      this.next();
      let maybeDefaultIdentifier = null;
      if (this.isContextual(128) && this.isPotentialImportPhase(false)) {
        maybeDefaultIdentifier = this.parseMaybeImportPhase(node, false);
      } else {
        node.importKind = "value";
      }
      return this.tsParseImportEqualsDeclaration(node, maybeDefaultIdentifier, true);
    } else if (this.eat(29)) {
      const assign = node;
      assign.expression = super.parseExpression();
      this.semicolon();
      this.sawUnambiguousESM = true;
      return this.finishNode(assign, "TSExportAssignment");
    } else if (this.eatContextual(93)) {
      const decl = node;
      this.expectContextual(126);
      decl.id = this.parseIdentifier();
      this.semicolon();
      return this.finishNode(decl, "TSNamespaceExportDeclaration");
    } else {
      return super.parseExport(node, decorators);
    }
  }
  isAbstractClass() {
    return this.isContextual(122) && this.lookahead().type === 80;
  }
  parseExportDefaultExpression() {
    if (this.isAbstractClass()) {
      const cls = this.startNode();
      this.next();
      cls.abstract = true;
      return this.parseClass(cls, true, true);
    }
    if (this.match(127)) {
      const result = this.tsParseInterfaceDeclaration(this.startNode());
      if (result) return result;
    }
    return super.parseExportDefaultExpression();
  }
  parseVarStatement(node, kind, allowMissingInitializer = false) {
    const {
      isAmbientContext
    } = this.state;
    const declaration = super.parseVarStatement(node, kind, allowMissingInitializer || isAmbientContext);
    if (!isAmbientContext) return declaration;
    for (const {
      id,
      init
    } of declaration.declarations) {
      if (!init) continue;
      if (kind !== "const" || !!id.typeAnnotation) {
        this.raise(TSErrors.InitializerNotAllowedInAmbientContext, {
          at: init
        });
      } else if (!isValidAmbientConstInitializer(init, this.hasPlugin("estree"))) {
        this.raise(TSErrors.ConstInitiailizerMustBeStringOrNumericLiteralOrLiteralEnumReference, {
          at: init
        });
      }
    }
    return declaration;
  }
  parseStatementContent(flags, decorators) {
    if (this.match(75) && this.isLookaheadContextual("enum")) {
      const node = this.startNode();
      this.expect(75);
      return this.tsParseEnumDeclaration(node, {
        const: true
      });
    }
    if (this.isContextual(124)) {
      return this.tsParseEnumDeclaration(this.startNode());
    }
    if (this.isContextual(127)) {
      const result = this.tsParseInterfaceDeclaration(this.startNode());
      if (result) return result;
    }
    return super.parseStatementContent(flags, decorators);
  }
  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({
      allowedModifiers: modifiers,
      disallowedModifiers: ["in", "out"],
      stopOnStartOfClassStaticBlock: true,
      errorTemplate: TSErrors.InvalidModifierOnTypeParameterPositions
    }, member);
    const callParseClassMemberWithIsStatic = () => {
      if (this.tsIsStartOfStaticBlocks()) {
        this.next();
        this.next();
        if (this.tsHasSomeModifiers(member, modifiers)) {
          this.raise(TSErrors.StaticBlockCannotHaveModifier, {
            at: this.state.curPosition()
          });
        }
        super.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, {
          at: member
        });
      }
      if (member.accessibility) {
        this.raise(TSErrors.IndexSignatureHasAccessibility, {
          at: member,
          modifier: member.accessibility
        });
      }
      if (member.declare) {
        this.raise(TSErrors.IndexSignatureHasDeclare, {
          at: member
        });
      }
      if (member.override) {
        this.raise(TSErrors.IndexSignatureHasOverride, {
          at: member
        });
      }
      return;
    }
    if (!this.state.inAbstractClass && member.abstract) {
      this.raise(TSErrors.NonAbstractClassHasAbstractMethod, {
        at: member
      });
    }
    if (member.override) {
      if (!state.hadSuperClass) {
        this.raise(TSErrors.OverrideNotInSubClass, {
          at: 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, {
        at: methodOrProp
      });
    }
    if (methodOrProp.declare && this.match(10)) {
      this.raise(TSErrors.ClassMethodHasDeclare, {
        at: methodOrProp
      });
    }
  }
  parseExpressionStatement(node, expr, decorators) {
    const decl = expr.type === "Identifier" ? this.tsParseExpressionStatement(node, expr, decorators) : undefined;
    return decl || super.parseExpressionStatement(node, expr, decorators);
  }
  shouldParseExportDeclaration() {
    if (this.tsIsDeclarationStart()) return true;
    return super.shouldParseExportDeclaration();
  }
  parseConditional(expr, startLoc, refExpressionErrors) {
    if (!this.state.maybeInArrowParameters || !this.match(17)) {
      return super.parseConditional(expr, startLoc, refExpressionErrors);
    }
    const result = this.tryParse(() => super.parseConditional(expr, 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, startLoc) {
    node = super.parseParenItem(node, startLoc);
    if (this.eat(17)) {
      node.optional = true;
      this.resetEndLocation(node);
    }
    if (this.match(14)) {
      const typeCastNode = this.startNodeAt(startLoc);
      typeCastNode.expression = node;
      typeCastNode.typeAnnotation = this.tsParseTypeAnnotation();
      return this.finishNode(typeCastNode, "TSTypeCastExpression");
    }
    return node;
  }
  parseExportDeclaration(node) {
    if (!this.state.isAmbientContext && this.isContextual(123)) {
      return this.tsInAmbientContext(() => this.parseExportDeclaration(node));
    }
    const startLoc = this.state.startLoc;
    const isDeclare = this.eatContextual(123);
    if (isDeclare && (this.isContextual(123) || !this.shouldParseExportDeclaration())) {
      throw this.raise(TSErrors.ExpectedAmbientAfterExportDeclare, {
        at: this.state.startLoc
      });
    }
    const isIdentifier = tokenIsIdentifier(this.state.type);
    const declaration = isIdentifier && this.tsTryParseExportDeclaration() || super.parseExportDeclaration(node);
    if (!declaration) return null;
    if (declaration.type === "TSInterfaceDeclaration" || declaration.type === "TSTypeAliasDeclaration" || isDeclare) {
      node.exportKind = "type";
    }
    if (isDeclare) {
      this.resetStartLocation(declaration, startLoc);
      declaration.declare = true;
    }
    return declaration;
  }
  parseClassId(node, isStatement, optionalId, bindingType) {
    if ((!isStatement || optionalId) && this.isContextual(111)) {
      return;
    }
    super.parseClassId(node, isStatement, optionalId, node.declare ? BIND_TS_AMBIENT : BIND_CLASS);
    const typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutConstModifiers);
    if (typeParameters) node.typeParameters = typeParameters;
  }
  parseClassPropertyAnnotation(node) {
    if (!node.optional) {
      if (this.eat(35)) {
        node.definite = true;
      } else if (this.eat(17)) {
        node.optional = true;
      }
    }
    const type = this.tsTryParseTypeAnnotation();
    if (type) node.typeAnnotation = type;
  }
  parseClassProperty(node) {
    this.parseClassPropertyAnnotation(node);
    if (this.state.isAmbientContext && !(node.readonly && !node.typeAnnotation) && 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,
        propertyName: 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, {
        at: node
      });
    }
    if (node.accessibility) {
      this.raise(TSErrors.PrivateElementHasAccessibility, {
        at: node,
        modifier: node.accessibility
      });
    }
    this.parseClassPropertyAnnotation(node);
    return super.parseClassPrivateProperty(node);
  }
  parseClassAccessorProperty(node) {
    this.parseClassPropertyAnnotation(node);
    if (node.optional) {
      this.raise(TSErrors.AccessorCannotBeOptional, {
        at: node
      });
    }
    return super.parseClassAccessorProperty(node);
  }
  pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) {
    const typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier);
    if (typeParameters && isConstructor) {
      this.raise(TSErrors.ConstructorHasTypeParameters, {
        at: typeParameters
      });
    }
    const {
      declare = false,
      kind
    } = method;
    if (declare && (kind === "get" || kind === "set")) {
      this.raise(TSErrors.DeclareAccessor, {
        at: method,
        kind
      });
    }
    if (typeParameters) method.typeParameters = typeParameters;
    super.pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper);
  }
  pushClassPrivateMethod(classBody, method, isGenerator, isAsync) {
    const typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier);
    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(111)) {
      node.implements = this.tsParseHeritageClause("implements");
    }
  }
  parseObjPropValue(prop, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors) {
    const typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier);
    if (typeParameters) prop.typeParameters = typeParameters;
    return super.parseObjPropValue(prop, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors);
  }
  parseFunctionParams(node, isConstructor) {
    const typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier);
    if (typeParameters) node.typeParameters = typeParameters;
    super.parseFunctionParams(node, isConstructor);
  }
  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(refExpressionErrors, afterLeftParse) {
    var _jsx, _jsx2, _typeCast, _jsx3, _typeCast2;
    let state;
    let jsx;
    let typeCast;
    if (this.hasPlugin("jsx") && (this.match(140) || 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)) {
      return super.parseMaybeAssign(refExpressionErrors, afterLeftParse);
    }
    if (!state || state === this.state) state = this.state.clone();
    let typeParameters;
    const arrow = this.tryParse(abort => {
      var _expr$extra, _typeParameters;
      typeParameters = this.tsParseTypeParameters(this.tsParseConstModifier);
      const expr = super.parseMaybeAssign(refExpressionErrors, afterLeftParse);
      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(refExpressionErrors, afterLeftParse), 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;
    }
    throw ((_jsx3 = jsx) == null ? void 0 : _jsx3.error) || arrow.error || ((_typeCast2 = typeCast) == null ? void 0 : _typeCast2.error);
  }
  reportReservedArrowTypeParam(node) {
    var _node$extra;
    if (node.params.length === 1 && !node.params[0].constraint && !((_node$extra = node.extra) != null && _node$extra.trailingComma) && this.getPluginOption("typescript", "disallowAmbiguousJSXLike")) {
      this.raise(TSErrors.ReservedArrowTypeParam, {
        at: node
      });
    }
  }
  parseMaybeUnary(refExpressionErrors, sawUnary) {
    if (!this.hasPlugin("jsx") && this.match(47)) {
      return this.tsParseTypeAssertion();
    }
    return super.parseMaybeUnary(refExpressionErrors, sawUnary);
  }
  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, flags) {
    if (!(flags & 2)) return param;
    if (this.eat(17)) {
      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 "ParenthesizedExpression":
        this.toAssignableParenthesizedExpression(node, isLHS);
        break;
      case "TSAsExpression":
      case "TSSatisfiesExpression":
      case "TSNonNullExpression":
      case "TSTypeAssertion":
        if (isLHS) {
          this.expressionScope.recordArrowParameterBindingError(TSErrors.UnexpectedTypeCastInParameter, {
            at: node
          });
        } else {
          this.raise(TSErrors.UnexpectedTypeCastInParameter, {
            at: node
          });
        }
        this.toAssignable(node.expression, isLHS);
        break;
      case "AssignmentExpression":
        if (!isLHS && node.left.type === "TSTypeCastExpression") {
          node.left = this.typeCastToParameter(node.left);
        }
      default:
        super.toAssignable(node, isLHS);
    }
  }
  toAssignableParenthesizedExpression(node, isLHS) {
    switch (node.expression.type) {
      case "TSAsExpression":
      case "TSSatisfiesExpression":
      case "TSNonNullExpression":
      case "TSTypeAssertion":
      case "ParenthesizedExpression":
        this.toAssignable(node.expression, isLHS);
        break;
      default:
        super.toAssignable(node, isLHS);
    }
  }
  checkToRestConversion(node, allowPattern) {
    switch (node.type) {
      case "TSAsExpression":
      case "TSSatisfiesExpression":
      case "TSTypeAssertion":
      case "TSNonNullExpression":
        this.checkToRestConversion(node.expression, false);
        break;
      default:
        super.checkToRestConversion(node, allowPattern);
    }
  }
  isValidLVal(type, isUnparenthesizedInAssign, binding) {
    return getOwn({
      TSTypeCastExpression: true,
      TSParameterProperty: "parameter",
      TSNonNullExpression: "expression",
      TSAsExpression: (binding !== BIND_NONE || !isUnparenthesizedInAssign) && ["expression", true],
      TSSatisfiesExpression: (binding !== BIND_NONE || !isUnparenthesizedInAssign) && ["expression", true],
      TSTypeAssertion: (binding !== BIND_NONE || !isUnparenthesizedInAssign) && ["expression", true]
    }, type) || super.isValidLVal(type, isUnparenthesizedInAssign, binding);
  }
  parseBindingAtom() {
    if (this.state.type === 78) {
      return this.parseIdentifier(true);
    }
    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;
    }
    return super.checkCommaAfterRest(close);
  }
  isClassMethod() {
    return this.match(47) || super.isClassMethod();
  }
  isClassProperty() {
    return this.match(35) || this.match(14) || super.isClassProperty();
  }
  parseMaybeDefault(startLoc, left) {
    const node = super.parseMaybeDefault(startLoc, left);
    if (node.type === "AssignmentPattern" && node.typeAnnotation && node.right.start < node.typeAnnotation.start) {
      this.raise(TSErrors.TypeAnnotationAfterAssign, {
        at: node.typeAnnotation
      });
    }
    return node;
  }
  getTokenFromCode(code) {
    if (this.state.inType) {
      if (code === 62) {
        this.finishOp(48, 1);
        return;
      }
      if (code === 60) {
        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, trailingCommaLoc, isLHS) {
    for (let i = 0; i < exprList.length; i++) {
      const expr = exprList[i];
      if ((expr == null ? void 0 : expr.type) === "TSTypeCastExpression") {
        exprList[i] = this.typeCastToParameter(expr);
      }
    }
    super.toAssignableList(exprList, trailingCommaLoc, isLHS);
  }
  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, isStatement, optionalId) {
    const oldInAbstractClass = this.state.inAbstractClass;
    this.state.inAbstractClass = !!node.abstract;
    try {
      return super.parseClass(node, isStatement, optionalId);
    } finally {
      this.state.inAbstractClass = oldInAbstractClass;
    }
  }
  tsParseAbstractDeclaration(node, decorators) {
    if (this.match(80)) {
      node.abstract = true;
      return this.maybeTakeDecorators(decorators, this.parseClass(node, true, false));
    } else if (this.isContextual(127)) {
      if (!this.hasFollowingLineBreak()) {
        node.abstract = true;
        this.raise(TSErrors.NonClassMethodPropertyHasAbstractModifer, {
          at: node
        });
        return this.tsParseInterfaceDeclaration(node);
      }
    } else {
      this.unexpected(null, 80);
    }
  }
  parseMethod(node, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope) {
    const method = super.parseMethod(node, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope);
    if (method.abstract) {
      const hasBody = this.hasPlugin("estree") ? !!method.value.body : !!method.body;
      if (hasBody) {
        const {
          key
        } = method;
        this.raise(TSErrors.AbstractMethodHasImplementation, {
          at: method,
          methodName: 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, bindingType) {
    if (!importedIsString && isMaybeTypeOnly) {
      this.parseTypeOnlyImportExportSpecifier(specifier, true, isInTypeOnlyImport);
      return this.finishNode(specifier, "ImportSpecifier");
    }
    specifier.importKind = "value";
    return super.parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, isInTypeOnlyImport ? BIND_TS_TYPE_IMPORT : BIND_FLAGS_TS_IMPORT);
  }
  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 = isImport ? this.parseIdentifier() : this.parseModuleExportName();
          canParseAsKeyword = false;
        } else {
          rightOfAs = secondAs;
          canParseAsKeyword = false;
        }
      } else if (tokenIsKeywordOrIdentifier(this.state.type)) {
        canParseAsKeyword = false;
        rightOfAs = isImport ? this.parseIdentifier() : this.parseModuleExportName();
      } else {
        hasTypeSpecifier = true;
        leftOfAs = firstAs;
      }
    } else if (tokenIsKeywordOrIdentifier(this.state.type)) {
      hasTypeSpecifier = true;
      if (isImport) {
        leftOfAs = this.parseIdentifier(true);
        if (!this.isContextual(93)) {
          this.checkReservedWord(leftOfAs.name, leftOfAs.loc.start, true, true);
        }
      } else {
        leftOfAs = this.parseModuleExportName();
      }
    }
    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.checkIdentifier(node[rightOfAsKey], hasTypeSpecifier ? BIND_TS_TYPE_IMPORT : BIND_FLAGS_TS_IMPORT);
    }
  }
};
function isPossiblyLiteralEnum(expression) {
  if (expression.type !== "MemberExpression") return false;
  const {
    computed,
    property
  } = expression;
  if (computed && property.type !== "StringLiteral" && (property.type !== "TemplateLiteral" || property.expressions.length > 0)) {
    return false;
  }
  return isUncomputedMemberExpressionChain(expression.object);
}
function isValidAmbientConstInitializer(expression, estree) {
  var _expression$extra;
  const {
    type
  } = expression;
  if ((_expression$extra = expression.extra) != null && _expression$extra.parenthesized) {
    return false;
  }
  if (estree) {
    if (type === "Literal") {
      const {
        value
      } = expression;
      if (typeof value === "string" || typeof value === "boolean") {
        return true;
      }
    }
  } else {
    if (type === "StringLiteral" || type === "BooleanLiteral") {
      return true;
    }
  }
  if (isNumber(expression, estree) || isNegativeNumber(expression, estree)) {
    return true;
  }
  if (type === "TemplateLiteral" && expression.expressions.length === 0) {
    return true;
  }
  if (isPossiblyLiteralEnum(expression)) {
    return true;
  }
  return false;
}
function isNumber(expression, estree) {
  if (estree) {
    return expression.type === "Literal" && (typeof expression.value === "number" || "bigint" in expression);
  }
  return expression.type === "NumericLiteral" || expression.type === "BigIntLiteral";
}
function isNegativeNumber(expression, estree) {
  if (expression.type === "UnaryExpression") {
    const {
      operator,
      argument
    } = expression;
    if (operator === "-" && isNumber(argument, estree)) {
      return true;
    }
  }
  return false;
}
function isUncomputedMemberExpressionChain(expression) {
  if (expression.type === "Identifier") return true;
  if (expression.type !== "MemberExpression" || expression.computed) {
    return false;
  }
  return isUncomputedMemberExpressionChain(expression.object);
}
const PlaceholderErrors = ParseErrorEnum`placeholders`({
  ClassNameIsRequired: "A class name is required.",
  UnexpectedSpace: "Unexpected space in placeholder."
});
var placeholders = superClass => class PlaceholdersParserMixin extends superClass {
  parsePlaceholder(expectedNode) {
    if (this.match(142)) {
      const node = this.startNode();
      this.next();
      this.assertNoSpace();
      node.name = super.parseIdentifier(true);
      this.assertNoSpace();
      this.expect(142);
      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) {
      this.finishOp(142, 2);
    } else {
      super.getTokenFromCode(code);
    }
  }
  parseExprAtom(refExpressionErrors) {
    return this.parsePlaceholder("Expression") || super.parseExprAtom(refExpressionErrors);
  }
  parseIdentifier(liberal) {
    return this.parsePlaceholder("Identifier") || super.parseIdentifier(liberal);
  }
  checkReservedWord(word, startLoc, checkKeywords, isBinding) {
    if (word !== undefined) {
      super.checkReservedWord(word, startLoc, checkKeywords, isBinding);
    }
  }
  parseBindingAtom() {
    return this.parsePlaceholder("Pattern") || super.parseBindingAtom();
  }
  isValidLVal(type, isParenthesized, binding) {
    return type === "Placeholder" || super.isValidLVal(type, isParenthesized, binding);
  }
  toAssignable(node, isLHS) {
    if (node && node.type === "Placeholder" && node.expectedNode === "Expression") {
      node.expectedNode = "Pattern";
    } else {
      super.toAssignable(node, isLHS);
    }
  }
  chStartsBindingIdentifier(ch, pos) {
    if (super.chStartsBindingIdentifier(ch, pos)) {
      return true;
    }
    const nextToken = this.lookahead();
    if (nextToken.type === 142) {
      return true;
    }
    return false;
  }
  verifyBreakContinue(node, isBreak) {
    if (node.label && node.label.type === "Placeholder") return;
    super.verifyBreakContinue(node, isBreak);
  }
  parseExpressionStatement(node, expr) {
    if (expr.type !== "Placeholder" || expr.extra && expr.extra.parenthesized) {
      return super.parseExpressionStatement(node, expr);
    }
    if (this.match(14)) {
      const stmt = node;
      stmt.label = this.finishPlaceholder(expr, "Identifier");
      this.next();
      stmt.body = super.parseStatementOrSloppyAnnexBFunctionDeclaration();
      return this.finishNode(stmt, "LabeledStatement");
    }
    this.semicolon();
    node.name = expr.name;
    return this.finishPlaceholder(node, "Statement");
  }
  parseBlock(allowDirectives, createNewLexicalScope, afterBlockParse) {
    return this.parsePlaceholder("BlockStatement") || super.parseBlock(allowDirectives, createNewLexicalScope, afterBlockParse);
  }
  parseFunctionId(requireId) {
    return this.parsePlaceholder("Identifier") || super.parseFunctionId(requireId);
  }
  parseClass(node, isStatement, optionalId) {
    const type = isStatement ? "ClassDeclaration" : "ClassExpression";
    this.next();
    const oldStrict = this.state.strict;
    const placeholder = this.parsePlaceholder("Identifier");
    if (placeholder) {
      if (this.match(81) || this.match(142) || 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);
    }
    super.parseClassSuper(node);
    node.body = this.parsePlaceholder("ClassBody") || super.parseClassBody(!!node.superClass, oldStrict);
    return this.finishNode(node, type);
  }
  parseExport(node, decorators) {
    const placeholder = this.parsePlaceholder("Identifier");
    if (!placeholder) return super.parseExport(node, decorators);
    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, decorators);
  }
  isExportDefaultSpecifier() {
    if (this.match(65)) {
      const next = this.nextTokenStart();
      if (this.isUnparsedContextual(next, "from")) {
        if (this.input.startsWith(tokenLabelName(142), this.nextTokenStartSince(next + 4))) {
          return true;
        }
      }
    }
    return super.isExportDefaultSpecifier();
  }
  maybeParseExportDefaultSpecifier(node, maybeDefaultIdentifier) {
    var _specifiers;
    if ((_specifiers = node.specifiers) != null && _specifiers.length) {
      return true;
    }
    return super.maybeParseExportDefaultSpecifier(node, maybeDefaultIdentifier);
  }
  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(node);
    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;
    node.specifiers.push(this.finishNode(specifier, "ImportDefaultSpecifier"));
    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();
  }
  assertNoSpace() {
    if (this.state.start > this.state.lastTokEndLoc.index) {
      this.raise(PlaceholderErrors.UnexpectedSpace, {
        at: this.state.lastTokEndLoc
      });
    }
  }
};
var v8intrinsic = superClass => class V8IntrinsicMixin 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();
        const identifier = this.createIdentifier(node, name);
        identifier.type = "V8IntrinsicIdentifier";
        if (this.match(10)) {
          return identifier;
        }
      }
      this.unexpected(v8IntrinsicStartLoc);
    }
  }
  parseExprAtom(refExpressionErrors) {
    return this.parseV8Intrinsic() || super.parseExprAtom(refExpressionErrors);
  }
};
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) && plugin.length > 1) {
    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 && typeof decoratorsBeforeExport !== "boolean") {
      throw new Error("'decoratorsBeforeExport' must be a boolean, if specified.");
    }
    const allowCallParenthesized = getPluginOption(plugins, "decorators", "allowCallParenthesized");
    if (allowCallParenthesized != null && typeof allowCallParenthesized !== "boolean") {
      throw new Error("'allowCallParenthesized' 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") || hasPlugin(plugins, "importAttributes")) {
        throw new Error("Cannot combine importAssertions, importAttributes and moduleAttributes plugins.");
      }
      const moduleAttributesVersionPluginOption = getPluginOption(plugins, "moduleAttributes", "version");
      if (moduleAttributesVersionPluginOption !== "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, "importAssertions") && hasPlugin(plugins, "importAttributes")) {
    throw new Error("Cannot combine importAssertions and importAttributes plugins.");
  }
  if (hasPlugin(plugins, "recordAndTuple") && getPluginOption(plugins, "recordAndTuple", "syntaxType") != null && !RECORD_AND_TUPLE_SYNTAX_TYPES.includes(getPluginOption(plugins, "recordAndTuple", "syntaxType"))) {
    throw new Error("The 'syntaxType' option of the 'recordAndTuple' plugin must 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,
  allowNewTargetOutsideFunction: false,
  allowImportExportEverywhere: false,
  allowSuperOutsideMethod: false,
  allowUndeclaredExports: false,
  plugins: [],
  strictMode: null,
  ranges: false,
  tokens: false,
  createParenthesizedExpressions: false,
  errorRecovery: false,
  attachComment: true,
  annexB: true
};
function getOptions(opts) {
  if (opts && opts.annexB != null && opts.annexB !== false) {
    throw new Error("The `annexB` option can only be set to `false`.");
  }
  const options = {};
  for (const key of Object.keys(defaultOptions)) {
    options[key] = opts && opts[key] != null ? opts[key] : defaultOptions[key];
  }
  return options;
}
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(Errors.RecordNoProto, {
          at: key
        });
        return;
      }
      if (protoRef.used) {
        if (refExpressionErrors) {
          if (refExpressionErrors.doubleProtoLoc === null) {
            refExpressionErrors.doubleProtoLoc = key.loc.start;
          }
        } else {
          this.raise(Errors.DuplicateProto, {
            at: 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(137)) {
      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 startLoc = this.state.startLoc;
    const expr = this.parseMaybeAssign(refExpressionErrors);
    if (this.match(12)) {
      const node = this.startNodeAt(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 startLoc = this.state.startLoc;
    if (this.isContextual(106)) {
      if (this.prodParam.hasYield) {
        let left = this.parseYield();
        if (afterLeftParse) {
          left = afterLeftParse.call(this, left, 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, startLoc);
    }
    if (tokenIsAssignment(this.state.type)) {
      const node = this.startNodeAt(startLoc);
      const operator = this.state.value;
      node.operator = operator;
      if (this.match(29)) {
        this.toAssignable(left, true);
        node.left = left;
        const startIndex = startLoc.index;
        if (refExpressionErrors.doubleProtoLoc != null && refExpressionErrors.doubleProtoLoc.index >= startIndex) {
          refExpressionErrors.doubleProtoLoc = null;
        }
        if (refExpressionErrors.shorthandAssignLoc != null && refExpressionErrors.shorthandAssignLoc.index >= startIndex) {
          refExpressionErrors.shorthandAssignLoc = null;
        }
        if (refExpressionErrors.privateKeyLoc != null && refExpressionErrors.privateKeyLoc.index >= startIndex) {
          this.checkDestructuringPrivate(refExpressionErrors);
          refExpressionErrors.privateKeyLoc = null;
        }
      } else {
        node.left = left;
      }
      this.next();
      node.right = this.parseMaybeAssign();
      this.checkLVal(left, {
        in: this.finishNode(node, "AssignmentExpression")
      });
      return node;
    } else if (ownExpressionErrors) {
      this.checkExpressionErrors(refExpressionErrors, true);
    }
    return left;
  }
  parseMaybeConditional(refExpressionErrors) {
    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, startLoc, refExpressionErrors);
  }
  parseConditional(expr, startLoc, refExpressionErrors) {
    if (this.eat(17)) {
      const node = this.startNodeAt(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(136) ? this.parsePrivateName() : this.parseMaybeUnary(refExpressionErrors);
  }
  parseExprOps(refExpressionErrors) {
    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, startLoc, -1);
  }
  parseExprOp(left, leftStartLoc, minPrec) {
    if (this.isPrivateName(left)) {
      const value = this.getPrivateNameSV(left);
      if (minPrec >= tokenOperatorPrecedence(58) || !this.prodParam.hasIn || !this.match(58)) {
        this.raise(Errors.PrivateInExpectedIn, {
          at: left,
          identifierName: 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(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(Errors.UnexpectedAwaitAfterPipelineBody, {
              at: this.state.startLoc
            });
          }
        }
        node.right = this.parseExprOpRightExpr(op, prec);
        const finishedNode = this.finishNode(node, logical || coalesce ? "LogicalExpression" : "BinaryExpression");
        const nextOp = this.state.type;
        if (coalesce && (nextOp === 41 || nextOp === 42) || logical && nextOp === 40) {
          throw this.raise(Errors.MixingCoalesceWithLogical, {
            at: this.state.startLoc
          });
        }
        return this.parseExprOp(finishedNode, leftStartLoc, minPrec);
      }
    }
    return left;
  }
  parseExprOpRightExpr(op, prec) {
    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(106)) {
                throw this.raise(Errors.PipeBodyIsTighter, {
                  at: this.state.startLoc
                });
              }
              return this.parseSmartPipelineBodyInStyle(this.parseExprOpBaseRightExpr(op, prec), startLoc);
            });
          case "fsharp":
            return this.withSoloAwaitPermittingContext(() => {
              return this.parseFSharpPipelineBody(prec);
            });
        }
      default:
        return this.parseExprOpBaseRightExpr(op, prec);
    }
  }
  parseExprOpBaseRightExpr(op, prec) {
    const startLoc = this.state.startLoc;
    return this.parseExprOp(this.parseMaybeUnaryOrPrivate(), startLoc, tokenIsRightAssociative(op) ? prec - 1 : prec);
  }
  parseHackPipeBody() {
    var _body$extra;
    const {
      startLoc
    } = this.state;
    const body = this.parseMaybeAssign();
    const requiredParentheses = UnparenthesizedPipeBodyDescriptions.has(body.type);
    if (requiredParentheses && !((_body$extra = body.extra) != null && _body$extra.parenthesized)) {
      this.raise(Errors.PipeUnparenthesizedBody, {
        at: startLoc,
        type: body.type
      });
    }
    if (!this.topicReferenceWasUsedInCurrentContext()) {
      this.raise(Errors.PipeTopicUnused, {
        at: startLoc
      });
    }
    return body;
  }
  checkExponentialAfterUnary(node) {
    if (this.match(57)) {
      this.raise(Errors.UnexpectedTokenUnaryExponentiation, {
        at: node.argument
      });
    }
  }
  parseMaybeUnary(refExpressionErrors, sawUnary) {
    const startLoc = this.state.startLoc;
    const isAwait = this.isContextual(96);
    if (isAwait && this.isAwaitAllowed()) {
      this.next();
      const expr = this.parseAwait(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(Errors.StrictDelete, {
            at: node
          });
        } else if (this.hasPropertyAsPrivateName(arg)) {
          this.raise(Errors.DeletePrivateField, {
            at: 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(Errors.AwaitNotInAsyncContext, {
          at: startLoc
        });
        return this.parseAwait(startLoc);
      }
    }
    return expr;
  }
  parseUpdate(node, update, refExpressionErrors) {
    if (update) {
      const updateExpressionNode = node;
      this.checkLVal(updateExpressionNode.argument, {
        in: this.finishNode(updateExpressionNode, "UpdateExpression")
      });
      return node;
    }
    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(startLoc);
      node.operator = this.state.value;
      node.prefix = false;
      node.argument = expr;
      this.next();
      this.checkLVal(expr, {
        in: expr = this.finishNode(node, "UpdateExpression")
      });
    }
    return expr;
  }
  parseExprSubscripts(refExpressionErrors) {
    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, startLoc);
  }
  parseSubscripts(base, startLoc, noCalls) {
    const state = {
      optionalChainMember: false,
      maybeAsyncArrow: this.atPossibleAsyncArrow(base),
      stop: false
    };
    do {
      base = this.parseSubscript(base, startLoc, noCalls, state);
      state.maybeAsyncArrow = false;
    } while (!state.stop);
    return base;
  }
  parseSubscript(base, startLoc, noCalls, state) {
    const {
      type
    } = this.state;
    if (!noCalls && type === 15) {
      return this.parseBind(base, startLoc, noCalls, state);
    } else if (tokenIsTemplate(type)) {
      return this.parseTaggedTemplateExpression(base, startLoc, state);
    }
    let optional = false;
    if (type === 18) {
      if (noCalls) {
        this.raise(Errors.OptionalChainingNoNew, {
          at: this.state.startLoc
        });
        if (this.lookaheadCharCode() === 40) {
          state.stop = true;
          return base;
        }
      }
      state.optionalChainMember = optional = true;
      this.next();
    }
    if (!noCalls && this.match(10)) {
      return this.parseCoverCallAndAsyncArrowHead(base, startLoc, state, optional);
    } else {
      const computed = this.eat(0);
      if (computed || optional || this.eat(16)) {
        return this.parseMember(base, startLoc, state, computed, optional);
      } else {
        state.stop = true;
        return base;
      }
    }
  }
  parseMember(base, startLoc, state, computed, optional) {
    const node = this.startNodeAt(startLoc);
    node.object = base;
    node.computed = computed;
    if (computed) {
      node.property = this.parseExpression();
      this.expect(3);
    } else if (this.match(136)) {
      if (base.type === "Super") {
        this.raise(Errors.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, startLoc, noCalls, state) {
    const node = this.startNodeAt(startLoc);
    node.object = base;
    this.next();
    node.callee = this.parseNoCallExpr();
    state.stop = true;
    return this.parseSubscripts(this.finishNode(node, "BindExpression"), startLoc, noCalls);
  }
  parseCoverCallAndAsyncArrowHead(base, startLoc, state, optional) {
    const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;
    let refExpressionErrors = null;
    this.state.maybeInArrowParameters = true;
    this.next();
    const node = this.startNodeAt(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);
    }
    let finishedNode = this.finishCallExpression(node, optionalChainMember);
    if (maybeAsyncArrow && this.shouldParseAsyncArrow() && !optional) {
      state.stop = true;
      this.checkDestructuringPrivate(refExpressionErrors);
      this.expressionScope.validateAsPattern();
      this.expressionScope.exit();
      finishedNode = this.parseAsyncArrowFromCallExpression(this.startNodeAt(startLoc), finishedNode);
    } else {
      if (maybeAsyncArrow) {
        this.checkExpressionErrors(refExpressionErrors, true);
        this.expressionScope.exit();
      }
      this.toReferencedArguments(finishedNode);
    }
    this.state.maybeInArrowParameters = oldMaybeInArrowParameters;
    return finishedNode;
  }
  toReferencedArguments(node, isParenthesizedExpr) {
    this.toReferencedListDeep(node.arguments, isParenthesizedExpr);
  }
  parseTaggedTemplateExpression(base, startLoc, state) {
    const node = this.startNodeAt(startLoc);
    node.tag = base;
    node.quasi = this.parseTemplate(true);
    if (state.optionalChainMember) {
      this.raise(Errors.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;
  }
  expectImportAttributesPlugin() {
    if (!this.hasPlugin("importAssertions")) {
      this.expectPlugin("importAttributes");
    }
  }
  finishCallExpression(node, optional) {
    if (node.callee.type === "Import") {
      if (node.arguments.length === 2) {
        {
          if (!this.hasPlugin("moduleAttributes")) {
            this.expectImportAttributesPlugin();
          }
        }
      }
      if (node.arguments.length === 0 || node.arguments.length > 2) {
        this.raise(Errors.ImportCallArity, {
          at: node,
          maxArgumentCount: this.hasPlugin("importAttributes") || this.hasPlugin("importAssertions") || this.hasPlugin("moduleAttributes") ? 2 : 1
        });
      } else {
        for (const arg of node.arguments) {
          if (arg.type === "SpreadElement") {
            this.raise(Errors.ImportCallSpreadArgument, {
              at: 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("importAttributes") && !this.hasPlugin("importAssertions") && !this.hasPlugin("moduleAttributes")) {
            this.raise(Errors.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 startLoc = this.state.startLoc;
    return this.parseSubscripts(this.parseExprAtom(), startLoc, true);
  }
  parseExprAtom(refExpressionErrors) {
    let node;
    let decorators = null;
    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(Errors.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 132:
        return this.parseNumericLiteral(this.state.value);
      case 133:
        return this.parseBigIntLiteral(this.state.value);
      case 134:
        return this.parseDecimalLiteral(this.state.value);
      case 131:
        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:
        decorators = this.parseDecorators();
      case 80:
        return this.parseClass(this.maybeTakeDecorators(decorators, this.startNode()), 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(Errors.UnsupportedBind, {
              at: callee
            });
          }
        }
      case 136:
        {
          this.raise(Errors.PrivateInExpectedIn, {
            at: this.state.startLoc,
            identifierName: 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);
          }
          this.unexpected();
          break;
        }
      case 47:
        {
          const lookaheadCh = this.input.codePointAt(this.nextTokenStart());
          if (isIdentifierStart(lookaheadCh) || lookaheadCh === 62) {
            this.expectOnePlugin(["jsx", "flow", "typescript"]);
          } else {
            this.unexpected();
          }
          break;
        }
      default:
        if (tokenIsIdentifier(type)) {
          if (this.isContextual(125) && this.lookaheadInLineCharCode() === 123) {
            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.parseAsyncFunctionExpression(this.startNodeAtNode(id));
            } 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 {
          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 {
      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" ? Errors.PrimaryTopicNotAllowed : Errors.PipeTopicUnbound, {
          at: startLoc
        });
      }
      this.registerTopicReference();
      return this.finishNode(node, nodeType);
    } else {
      throw this.raise(Errors.PipeTopicUnconfiguredToken, {
        at: startLoc,
        token: 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(Errors.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(Errors.LineTerminatorBeforeArrow, {
        at: this.state.curPosition()
      });
    }
    this.expect(19);
    return this.parseArrowExpression(node, params, true);
  }
  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(Errors.SuperNotAllowed, {
        at: node
      });
    } else if (!this.scope.allowSuper && !this.options.allowSuperOutsideMethod) {
      this.raise(Errors.UnexpectedSuper, {
        at: node
      });
    }
    if (!this.match(10) && !this.match(0) && !this.match(16)) {
      this.raise(Errors.UnsupportedSuper, {
        at: node
      });
    }
    return this.finishNode(node, "Super");
  }
  parsePrivateName() {
    const node = this.startNode();
    const id = this.startNodeAt(createPositionWithColumnOffset(this.state.startLoc, 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(Errors.UnsupportedMetaProperty, {
        at: node.property,
        target: meta.name,
        onlyValidPropertyName: 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(Errors.ImportMetaOutsideModule, {
          at: 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 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 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 spreadNodeStartLoc = this.state.startLoc;
        spreadStartLoc = this.state.startLoc;
        exprList.push(this.parseParenItem(this.parseRestBinding(), 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(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(innerStartLoc);
      val.expressions = exprList;
      this.finishNode(val, "SequenceExpression");
      this.resetEndLocation(val, innerEndLoc);
    } else {
      val = exprList[0];
    }
    return this.wrapParenthesis(startLoc, val);
  }
  wrapParenthesis(startLoc, expression) {
    if (!this.options.createParenthesizedExpressions) {
      this.addExtra(expression, "parenthesized", true);
      this.addExtra(expression, "parenStart", startLoc.index);
      this.takeSurroundingComments(expression, startLoc.index, this.state.lastTokEndLoc.index);
      return expression;
    }
    const parenExpression = this.startNodeAt(startLoc);
    parenExpression.expression = expression;
    return this.finishNode(parenExpression, "ParenthesizedExpression");
  }
  shouldParseArrow(params) {
    return !this.canInsertSemicolon();
  }
  parseArrow(node) {
    if (this.eat(19)) {
      return node;
    }
  }
  parseParenItem(node, 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.options.allowNewTargetOutsideFunction) {
        this.raise(Errors.UnexpectedNewTarget, {
          at: metaProp
        });
      }
      return metaProp;
    }
    return this.parseNew(node);
  }
  parseNew(node) {
    this.parseNewCallee(node);
    if (this.eat(10)) {
      const args = this.parseExprList(11);
      this.toReferencedList(args);
      node.arguments = args;
    } else {
      node.arguments = [];
    }
    return this.finishNode(node, "NewExpression");
  }
  parseNewCallee(node) {
    node.callee = this.parseNoCallExpr();
    if (node.callee.type === "Import") {
      this.raise(Errors.ImportCallNotNewExpression, {
        at: node.callee
      });
    }
  }
  parseTemplateElement(isTagged) {
    const {
      start,
      startLoc,
      end,
      value
    } = this.state;
    const elemStart = start + 1;
    const elem = this.startNodeAt(createPositionWithColumnOffset(startLoc, 1));
    if (value === null) {
      if (!isTagged) {
        this.raise(Errors.InvalidEscapeSequenceTemplate, {
          at: createPositionWithColumnOffset(this.state.firstInvalidTemplateEscapePos, 1)
        });
      }
    }
    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();
    const finishedNode = this.finishNode(elem, "TemplateElement");
    this.resetEndLocation(finishedNode, createPositionWithColumnOffset(this.state.lastTokEndLoc, endOffset));
    return finishedNode;
  }
  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(Errors.InvalidRecordProperty, {
          at: 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(Errors.UnsupportedPropertyDecorator, {
          at: this.state.startLoc
        });
      }
      while (this.match(26)) {
        decorators.push(this.parseDecorator());
      }
    }
    const prop = this.startNode();
    let isAsync = false;
    let isAccessor = false;
    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) {
      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(Errors.AccessorIsGenerator, {
            at: this.state.curPosition(),
            kind: keyName
          });
          this.next();
        }
        this.parsePropertyName(prop);
      }
    }
    return this.parseObjPropValue(prop, startLoc, isGenerator, isAsync, false, isAccessor, refExpressionErrors);
  }
  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" ? Errors.BadGetterArity : Errors.BadSetterArity, {
        at: method
      });
    }
    if (method.kind === "set" && ((_params = params[params.length - 1]) == null ? void 0 : _params.type) === "RestElement") {
      this.raise(Errors.BadSetterRestParameter, {
        at: method
      });
    }
  }
  parseObjectMethod(prop, isGenerator, isAsync, isPattern, isAccessor) {
    if (isAccessor) {
      const finishedProp = this.parseMethod(prop, isGenerator, false, false, false, "ObjectMethod");
      this.checkGetterSetterParams(finishedProp);
      return finishedProp;
    }
    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, startLoc, isPattern, refExpressionErrors) {
    prop.shorthand = false;
    if (this.eat(14)) {
      prop.value = isPattern ? this.parseMaybeDefault(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(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(Errors.InvalidCoverInitializedName, {
            at: shorthandAssignLoc
          });
        }
        prop.value = this.parseMaybeDefault(startLoc, cloneIdentifier(prop.key));
      } else {
        prop.value = cloneIdentifier(prop.key);
      }
      prop.shorthand = true;
      return this.finishNode(prop, "ObjectProperty");
    }
  }
  parseObjPropValue(prop, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors) {
    const node = this.parseObjectMethod(prop, isGenerator, isAsync, isPattern, isAccessor) || this.parseObjectProperty(prop, 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 132:
            key = this.parseNumericLiteral(value);
            break;
          case 131:
            key = this.parseStringLiteral(value);
            break;
          case 133:
            key = this.parseBigIntLiteral(value);
            break;
          case 134:
            key = this.parseDecimalLiteral(value);
            break;
          case 136:
            {
              const privateKeyLoc = this.state.startLoc;
              if (refExpressionErrors != null) {
                if (refExpressionErrors.privateKeyLoc === null) {
                  refExpressionErrors.privateKeyLoc = privateKeyLoc;
                }
              } else {
                this.raise(Errors.UnexpectedPrivateField, {
                  at: privateKeyLoc
                });
              }
              key = this.parsePrivateName();
              break;
            }
          default:
            this.unexpected();
        }
      }
      prop.key = key;
      if (type !== 136) {
        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;
    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, isConstructor);
    const finishedNode = this.parseFunctionBodyAndFinish(node, type, true);
    this.prodParam.exit();
    this.scope.exit();
    return finishedNode;
  }
  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) {
    this.toAssignableList(params, trailingCommaLoc, false);
    node.params = params;
  }
  parseFunctionBodyAndFinish(node, type, isMethod = false) {
    this.parseFunctionBody(node, false, isMethod);
    return 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) {
          this.raise(Errors.IllegalLanguageModeDirective, {
            at: (node.kind === "method" || node.kind === "constructor") && !!node.key ? node.key.loc.end : node
          });
        }
        const strictModeChanged = !oldStrict && this.state.strict;
        this.checkParams(node, !this.state.strict && !allowExpression && !isMethod && !nonSimple, allowExpression, strictModeChanged);
        if (this.state.strict && node.id) {
          this.checkIdentifier(node.id, BIND_OUTSIDE, strictModeChanged);
        }
      });
      this.prodParam.exit();
      this.state.labels = oldLabels;
    }
    this.expressionScope.exit();
  }
  isSimpleParameter(node) {
    return node.type === "Identifier";
  }
  isSimpleParamList(params) {
    for (let i = 0, len = params.length; i < len; i++) {
      if (!this.isSimpleParameter(params[i])) return false;
    }
    return true;
  }
  checkParams(node, allowDuplicates, isArrowFunction, strictModeChanged = true) {
    const checkClashes = !allowDuplicates && new Set();
    const formalParameters = {
      type: "FormalParameters"
    };
    for (const param of node.params) {
      this.checkLVal(param, {
        in: formalParameters,
        binding: BIND_VAR,
        checkClashes,
        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(Errors.UnexpectedToken, {
          at: this.state.curPosition(),
          unexpected: ","
        });
      }
      elt = null;
    } else if (this.match(21)) {
      const spreadNodeStartLoc = this.state.startLoc;
      elt = this.parseParenItem(this.parseSpread(refExpressionErrors), spreadNodeStartLoc);
    } else if (this.match(17)) {
      this.expectPlugin("partialApplication");
      if (!allowPlaceholder) {
        this.raise(Errors.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(liberal);
    return this.createIdentifier(node, name);
  }
  createIdentifier(node, name) {
    node.name = name;
    node.loc.identifierName = name;
    return this.finishNode(node, "Identifier");
  }
  parseIdentifierName(liberal) {
    let name;
    const {
      startLoc,
      type
    } = this.state;
    if (tokenIsKeywordOrIdentifier(type)) {
      name = this.state.value;
    } else {
      this.unexpected();
    }
    const tokenIsKeyword = tokenKeywordOrIdentifierIsKeyword(type);
    if (liberal) {
      if (tokenIsKeyword) {
        this.replaceToken(130);
      }
    } 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 (checkKeywords && isKeyword(word)) {
      this.raise(Errors.UnexpectedKeyword, {
        at: startLoc,
        keyword: word
      });
      return;
    }
    const reservedTest = !this.state.strict ? isReservedWord : isBinding ? isStrictBindReservedWord : isStrictReservedWord;
    if (reservedTest(word, this.inModule)) {
      this.raise(Errors.UnexpectedReservedWord, {
        at: startLoc,
        reservedWord: word
      });
      return;
    } else if (word === "yield") {
      if (this.prodParam.hasYield) {
        this.raise(Errors.YieldBindingIdentifier, {
          at: startLoc
        });
        return;
      }
    } else if (word === "await") {
      if (this.prodParam.hasAwait) {
        this.raise(Errors.AwaitBindingIdentifier, {
          at: startLoc
        });
        return;
      }
      if (this.scope.inStaticBlock) {
        this.raise(Errors.AwaitBindingIdentifierInStaticBlock, {
          at: startLoc
        });
        return;
      }
      this.expressionScope.recordAsyncArrowParametersError({
        at: startLoc
      });
    } else if (word === "arguments") {
      if (this.scope.inClassAndNotInNonArrowFunction) {
        this.raise(Errors.ArgumentsInClass, {
          at: startLoc
        });
        return;
      }
    }
  }
  isAwaitAllowed() {
    if (this.prodParam.hasAwait) return true;
    if (this.options.allowAwaitOutsideFunction && !this.scope.inFunction) {
      return true;
    }
    return false;
  }
  parseAwait(startLoc) {
    const node = this.startNodeAt(startLoc);
    this.expressionScope.recordParameterInitializerError(Errors.AwaitExpressionFormalParameter, {
      at: node
    });
    if (this.eat(55)) {
      this.raise(Errors.ObsoleteAwaitStar, {
        at: 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 === 101 && !this.state.containsEsc || type === 135 || type === 56 || this.hasPlugin("v8intrinsic") && type === 54;
  }
  parseYield() {
    const node = this.startNode();
    this.expressionScope.recordParameterInitializerError(Errors.YieldInParameter, {
      at: node
    });
    this.next();
    let delegating = false;
    let argument = null;
    if (!this.hasPrecedingLineBreak()) {
      delegating = this.eat(55);
      switch (this.state.type) {
        case 13:
        case 137:
        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(Errors.PipelineHeadSequenceExpression, {
          at: leftStartLoc
        });
      }
    }
  }
  parseSmartPipelineBodyInStyle(childExpr, startLoc) {
    if (this.isSimpleReference(childExpr)) {
      const bodyNode = this.startNodeAt(startLoc);
      bodyNode.callee = childExpr;
      return this.finishNode(bodyNode, "PipelineBareFunction");
    } else {
      const bodyNode = this.startNodeAt(startLoc);
      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(Errors.PipelineBodyNoArrow, {
        at: this.state.startLoc
      });
    }
    if (!this.topicReferenceWasUsedInCurrentContext()) {
      this.raise(Errors.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 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(), startLoc, prec);
    this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;
    return ret;
  }
  parseModuleExpression() {
    this.expectPlugin("moduleBlocks");
    const node = this.startNode();
    this.next();
    if (!this.match(5)) {
      this.unexpected(null, 5);
    }
    const program = this.startNodeAt(this.state.endLoc);
    this.next();
    const revertScopes = this.initializeScopes(true);
    this.enterInitialScopes();
    try {
      node.body = this.parseProgram(program, 8, "module");
    } finally {
      revertScopes();
    }
    return this.finishNode(node, "ModuleExpression");
  }
  parsePropertyNamePrefixOperator(prop) {}
}
const loopLabel = {
    kind: "loop"
  },
  switchLabel = {
    kind: "switch"
  };
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 === 136) {
          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(130),
            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 = 137, 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 [localName, at] of Array.from(this.scope.undefinedExports)) {
        this.raise(Errors.ModuleExportUndefined, {
          at,
          localName
        });
      }
    }
    let finishedProgram;
    if (end === 137) {
      finishedProgram = this.finishNode(program, "Program");
    } else {
      finishedProgram = this.finishNodeAt(program, "Program", createPositionWithColumnOffset(this.state.startLoc, -1));
    }
    return finishedProgram;
  }
  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() {
    if (!this.isContextual(99)) {
      return false;
    }
    return this.hasFollowingBindingAtom();
  }
  chStartsBindingIdentifier(ch, pos) {
    if (isIdentifierStart(ch)) {
      keywordRelationalOperator.lastIndex = pos;
      if (keywordRelationalOperator.test(this.input)) {
        const endCh = this.codePointAtPos(keywordRelationalOperator.lastIndex);
        if (!isIdentifierChar(endCh) && endCh !== 92) {
          return false;
        }
      }
      return true;
    } else if (ch === 92) {
      return true;
    } else {
      return false;
    }
  }
  chStartsBindingPattern(ch) {
    return ch === 91 || ch === 123;
  }
  hasFollowingBindingAtom() {
    const next = this.nextTokenStart();
    const nextCh = this.codePointAtPos(next);
    return this.chStartsBindingPattern(nextCh) || this.chStartsBindingIdentifier(nextCh, next);
  }
  hasInLineFollowingBindingIdentifier() {
    const next = this.nextTokenInLineStart();
    const nextCh = this.codePointAtPos(next);
    return this.chStartsBindingIdentifier(nextCh, next);
  }
  startsUsingForOf() {
    const {
      type,
      containsEsc
    } = this.lookahead();
    if (type === 101 && !containsEsc) {
      return false;
    } else if (tokenIsIdentifier(type) && !this.hasFollowingLineBreak()) {
      this.expectPlugin("explicitResourceManagement");
      return true;
    }
  }
  startsAwaitUsing() {
    let next = this.nextTokenInLineStart();
    if (this.isUnparsedContextual(next, "using")) {
      next = this.nextTokenInLineStartSince(next + 5);
      const nextCh = this.codePointAtPos(next);
      if (this.chStartsBindingIdentifier(nextCh, next)) {
        this.expectPlugin("explicitResourceManagement");
        return true;
      }
    }
    return false;
  }
  parseModuleItem() {
    return this.parseStatementLike(1 | 2 | 4 | 8);
  }
  parseStatementListItem() {
    return this.parseStatementLike(2 | 4 | (!this.options.annexB || this.state.strict ? 0 : 8));
  }
  parseStatementOrSloppyAnnexBFunctionDeclaration(allowLabeledFunction = false) {
    let flags = 0;
    if (this.options.annexB && !this.state.strict) {
      flags |= 4;
      if (allowLabeledFunction) {
        flags |= 8;
      }
    }
    return this.parseStatementLike(flags);
  }
  parseStatement() {
    return this.parseStatementLike(0);
  }
  parseStatementLike(flags) {
    let decorators = null;
    if (this.match(26)) {
      decorators = this.parseDecorators(true);
    }
    return this.parseStatementContent(flags, decorators);
  }
  parseStatementContent(flags, decorators) {
    const starttype = this.state.type;
    const node = this.startNode();
    const allowDeclaration = !!(flags & 2);
    const allowFunctionDeclaration = !!(flags & 4);
    const topLevel = flags & 1;
    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.parseDoWhileStatement(node);
      case 91:
        return this.parseForStatement(node);
      case 68:
        if (this.lookaheadCharCode() === 46) break;
        if (!allowFunctionDeclaration) {
          this.raise(this.state.strict ? Errors.StrictFunction : this.options.annexB ? Errors.SloppyFunctionAnnexB : Errors.SloppyFunction, {
            at: this.state.startLoc
          });
        }
        return this.parseFunctionStatement(node, false, !allowDeclaration && allowFunctionDeclaration);
      case 80:
        if (!allowDeclaration) this.unexpected();
        return this.parseClass(this.maybeTakeDecorators(decorators, 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 96:
        if (!this.state.containsEsc && this.startsAwaitUsing()) {
          if (!this.isAwaitAllowed()) {
            this.raise(Errors.AwaitUsingNotInAsyncContext, {
              at: node
            });
          } else if (!allowDeclaration) {
            this.raise(Errors.UnexpectedLexicalDeclaration, {
              at: node
            });
          }
          this.next();
          return this.parseVarStatement(node, "await using");
        }
        break;
      case 105:
        if (this.state.containsEsc || !this.hasInLineFollowingBindingIdentifier()) {
          break;
        }
        this.expectPlugin("explicitResourceManagement");
        if (!this.scope.inModule && this.scope.inTopLevel) {
          this.raise(Errors.UnexpectedUsingDeclaration, {
            at: this.state.startLoc
          });
        } else if (!allowDeclaration) {
          this.raise(Errors.UnexpectedLexicalDeclaration, {
            at: this.state.startLoc
          });
        }
        return this.parseVarStatement(node, "using");
      case 99:
        {
          if (this.state.containsEsc) {
            break;
          }
          const next = this.nextTokenStart();
          const nextCh = this.codePointAtPos(next);
          if (nextCh !== 91) {
            if (!allowDeclaration && this.hasFollowingLineBreak()) break;
            if (!this.chStartsBindingIdentifier(nextCh, next) && nextCh !== 123) {
              break;
            }
          }
        }
      case 75:
        {
          if (!allowDeclaration) {
            this.raise(Errors.UnexpectedLexicalDeclaration, {
              at: this.state.startLoc
            });
          }
        }
      case 74:
        {
          const kind = this.state.value;
          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(Errors.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, decorators);
            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(result);
          return result;
        }
      default:
        {
          if (this.isAsyncFunction()) {
            if (!allowDeclaration) {
              this.raise(Errors.AsyncFunctionInSingleStatementContext, {
                at: this.state.startLoc
              });
            }
            this.next();
            return this.parseFunctionStatement(node, true, !allowDeclaration && allowFunctionDeclaration);
          }
        }
    }
    const maybeName = this.state.value;
    const expr = this.parseExpression();
    if (tokenIsIdentifier(starttype) && expr.type === "Identifier" && this.eat(14)) {
      return this.parseLabeledStatement(node, maybeName, expr, flags);
    } else {
      return this.parseExpressionStatement(node, expr, decorators);
    }
  }
  assertModuleNodeAllowed(node) {
    if (!this.options.allowImportExportEverywhere && !this.inModule) {
      this.raise(Errors.ImportOutsideModule, {
        at: node
      });
    }
  }
  decoratorsEnabledBeforeExport() {
    if (this.hasPlugin("decorators-legacy")) return true;
    return this.hasPlugin("decorators") && this.getPluginOption("decorators", "decoratorsBeforeExport") !== false;
  }
  maybeTakeDecorators(maybeDecorators, classNode, exportNode) {
    if (maybeDecorators) {
      if (classNode.decorators && classNode.decorators.length > 0) {
        if (typeof this.getPluginOption("decorators", "decoratorsBeforeExport") !== "boolean") {
          this.raise(Errors.DecoratorsBeforeAfterExport, {
            at: classNode.decorators[0]
          });
        }
        classNode.decorators.unshift(...maybeDecorators);
      } else {
        classNode.decorators = maybeDecorators;
      }
      this.resetStartLocationFromNode(classNode, maybeDecorators[0]);
      if (exportNode) this.resetStartLocationFromNode(exportNode, classNode);
    }
    return classNode;
  }
  canHaveLeadingDecorator() {
    return this.match(80);
  }
  parseDecorators(allowExport) {
    const decorators = [];
    do {
      decorators.push(this.parseDecorator());
    } while (this.match(26));
    if (this.match(82)) {
      if (!allowExport) {
        this.unexpected();
      }
      if (!this.decoratorsEnabledBeforeExport()) {
        this.raise(Errors.DecoratorExportClass, {
          at: this.state.startLoc
        });
      }
    } else if (!this.canHaveLeadingDecorator()) {
      throw this.raise(Errors.UnexpectedLeadingDecorator, {
        at: this.state.startLoc
      });
    }
    return decorators;
  }
  parseDecorator() {
    this.expectOnePlugin(["decorators", "decorators-legacy"]);
    const node = this.startNode();
    this.next();
    if (this.hasPlugin("decorators")) {
      const startLoc = this.state.startLoc;
      let expr;
      if (this.match(10)) {
        const startLoc = this.state.startLoc;
        this.next();
        expr = this.parseExpression();
        this.expect(11);
        expr = this.wrapParenthesis(startLoc, expr);
        const paramsStartLoc = this.state.startLoc;
        node.expression = this.parseMaybeDecoratorArguments(expr);
        if (this.getPluginOption("decorators", "allowCallParenthesized") === false && node.expression !== expr) {
          this.raise(Errors.DecoratorArgumentsOutsideParentheses, {
            at: paramsStartLoc
          });
        }
      } else {
        expr = this.parseIdentifier(false);
        while (this.eat(16)) {
          const node = this.startNodeAt(startLoc);
          node.object = expr;
          if (this.match(136)) {
            this.classScope.usePrivateName(this.state.value, this.state.startLoc);
            node.property = this.parsePrivateName();
          } else {
            node.property = this.parseIdentifier(true);
          }
          node.computed = false;
          expr = this.finishNode(node, "MemberExpression");
        }
        node.expression = this.parseMaybeDecoratorArguments(expr);
      }
    } 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) {
      const type = isBreak ? "BreakStatement" : "ContinueStatement";
      this.raise(Errors.IllegalBreakContinue, {
        at: node,
        type
      });
    }
  }
  parseDebuggerStatement(node) {
    this.next();
    this.semicolon();
    return this.finishNode(node, "DebuggerStatement");
  }
  parseHeaderExpression() {
    this.expect(10);
    const val = this.parseExpression();
    this.expect(11);
    return val;
  }
  parseDoWhileStatement(node) {
    this.next();
    this.state.labels.push(loopLabel);
    node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement());
    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 startsWithAwaitUsing = this.isContextual(96) && this.startsAwaitUsing();
      const starsWithUsingDeclaration = startsWithAwaitUsing || this.isContextual(105) && this.startsUsingForOf();
      const isLetOrUsing = startsWithLet && this.hasFollowingBindingAtom() || starsWithUsingDeclaration;
      if (this.match(74) || this.match(75) || isLetOrUsing) {
        const initNode = this.startNode();
        let kind;
        if (startsWithAwaitUsing) {
          kind = "await using";
          if (!this.isAwaitAllowed()) {
            this.raise(Errors.AwaitUsingNotInAsyncContext, {
              at: this.state.startLoc
            });
          }
          this.next();
        } else {
          kind = this.state.value;
        }
        this.next();
        this.parseVar(initNode, true, kind);
        const init = this.finishNode(initNode, "VariableDeclaration");
        const isForIn = this.match(58);
        if (isForIn && starsWithUsingDeclaration) {
          this.raise(Errors.ForInUsing, {
            at: init
          });
        }
        if ((isForIn || 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(Errors.ForOfLet, {
          at: init
        });
      }
      if (awaitAt === null && startsWithAsync && init.type === "Identifier") {
        this.raise(Errors.ForOfAsync, {
          at: init
        });
      }
    }
    if (isForOf || this.match(58)) {
      this.checkDestructuringPrivate(refExpressionErrors);
      this.toAssignable(init, true);
      const type = isForOf ? "ForOfStatement" : "ForInStatement";
      this.checkLVal(init, {
        in: {
          type
        }
      });
      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, isHangingDeclaration) {
    this.next();
    return this.parseFunction(node, 1 | (isHangingDeclaration ? 2 : 0) | (isAsync ? 8 : 0));
  }
  parseIfStatement(node) {
    this.next();
    node.test = this.parseHeaderExpression();
    node.consequent = this.parseStatementOrSloppyAnnexBFunctionDeclaration();
    node.alternate = this.eat(66) ? this.parseStatementOrSloppyAnnexBFunctionDeclaration() : null;
    return this.finishNode(node, "IfStatement");
  }
  parseReturnStatement(node) {
    if (!this.prodParam.hasReturn && !this.options.allowReturnOutsideFunction) {
      this.raise(Errors.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(Errors.MultipleDefaultsInSwitch, {
              at: this.state.lastTokStartLoc
            });
          }
          sawDefault = true;
          cur.test = null;
        }
        this.expect(14);
      } else {
        if (cur) {
          cur.consequent.push(this.parseStatementListItem());
        } 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(Errors.NewlineAfterThrow, {
        at: this.state.lastTokEndLoc
      });
    }
    node.argument = this.parseExpression();
    this.semicolon();
    return this.finishNode(node, "ThrowStatement");
  }
  parseCatchClauseParam() {
    const param = this.parseBindingAtom();
    this.scope.enter(this.options.annexB && param.type === "Identifier" ? SCOPE_SIMPLE_CATCH : 0);
    this.checkLVal(param, {
      in: {
        type: "CatchClause"
      },
      binding: BIND_CATCH_PARAM
    });
    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(Errors.NoCatchOrFinally, {
        at: node
      });
    }
    return this.finishNode(node, "TryStatement");
  }
  parseVarStatement(node, kind, allowMissingInitializer = false) {
    this.next();
    this.parseVar(node, false, kind, allowMissingInitializer);
    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());
    this.state.labels.pop();
    return this.finishNode(node, "WhileStatement");
  }
  parseWithStatement(node) {
    if (this.state.strict) {
      this.raise(Errors.StrictWith, {
        at: this.state.startLoc
      });
    }
    this.next();
    node.object = this.parseHeaderExpression();
    node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement());
    return this.finishNode(node, "WithStatement");
  }
  parseEmptyStatement(node) {
    this.next();
    return this.finishNode(node, "EmptyStatement");
  }
  parseLabeledStatement(node, maybeName, expr, flags) {
    for (const label of this.state.labels) {
      if (label.name === maybeName) {
        this.raise(Errors.LabelRedeclaration, {
          at: expr,
          labelName: 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 = flags & 8 ? this.parseStatementOrSloppyAnnexBFunctionDeclaration(true) : this.parseStatement();
    this.state.labels.pop();
    node.label = expr;
    return this.finishNode(node, "LabeledStatement");
  }
  parseExpressionStatement(node, expr, decorators) {
    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 = topLevel ? this.parseModuleItem() : this.parseStatementListItem();
      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());
    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.options.annexB || this.state.strict || init.kind !== "var" || init.declarations[0].id.type !== "Identifier")) {
      this.raise(Errors.ForInOfLoopInitializer, {
        at: init,
        type: isForIn ? "ForInStatement" : "ForOfStatement"
      });
    }
    if (init.type === "AssignmentPattern") {
      this.raise(Errors.InvalidLhs, {
        at: init,
        ancestor: {
          type: "ForStatement"
        }
      });
    }
    node.left = init;
    node.right = isForIn ? this.parseExpression() : this.parseMaybeAssignAllowIn();
    this.expect(11);
    node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement());
    this.scope.exit();
    this.state.labels.pop();
    return this.finishNode(node, isForIn ? "ForInStatement" : "ForOfStatement");
  }
  parseVar(node, isFor, kind, allowMissingInitializer = false) {
    const declarations = node.declarations = [];
    node.kind = kind;
    for (;;) {
      const decl = this.startNode();
      this.parseVarId(decl, kind);
      decl.init = !this.eat(29) ? null : isFor ? this.parseMaybeAssignDisallowIn() : this.parseMaybeAssignAllowIn();
      if (decl.init === null && !allowMissingInitializer) {
        if (decl.id.type !== "Identifier" && !(isFor && (this.match(58) || this.isContextual(101)))) {
          this.raise(Errors.DeclarationMissingInitializer, {
            at: this.state.lastTokEndLoc,
            kind: "destructuring"
          });
        } else if (kind === "const" && !(this.match(58) || this.isContextual(101))) {
          this.raise(Errors.DeclarationMissingInitializer, {
            at: this.state.lastTokEndLoc,
            kind: "const"
          });
        }
      }
      declarations.push(this.finishNode(decl, "VariableDeclarator"));
      if (!this.eat(12)) break;
    }
    return node;
  }
  parseVarId(decl, kind) {
    const id = this.parseBindingAtom();
    this.checkLVal(id, {
      in: {
        type: "VariableDeclarator"
      },
      binding: kind === "var" ? BIND_VAR : BIND_LEXICAL
    });
    decl.id = id;
  }
  parseAsyncFunctionExpression(node) {
    return this.parseFunction(node, 8);
  }
  parseFunction(node, flags = 0) {
    const hangingDeclaration = flags & 2;
    const isDeclaration = !!(flags & 1);
    const requireId = isDeclaration && !(flags & 4);
    const isAsync = !!(flags & 8);
    this.initFunction(node, isAsync);
    if (this.match(55)) {
      if (hangingDeclaration) {
        this.raise(Errors.GeneratorInSingleStatementContext, {
          at: this.state.startLoc
        });
      }
      this.next();
      node.generator = true;
    }
    if (isDeclaration) {
      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 (!isDeclaration) {
      node.id = this.parseFunctionId();
    }
    this.parseFunctionParams(node, false);
    this.withSmartMixTopicForbiddingContext(() => {
      this.parseFunctionBodyAndFinish(node, isDeclaration ? "FunctionDeclaration" : "FunctionExpression");
    });
    this.prodParam.exit();
    this.scope.exit();
    if (isDeclaration && !hangingDeclaration) {
      this.registerFunctionStatementId(node);
    }
    this.state.maybeInArrowParameters = oldMaybeInArrowParameters;
    return node;
  }
  parseFunctionId(requireId) {
    return requireId || tokenIsIdentifier(this.state.type) ? this.parseIdentifier() : null;
  }
  parseFunctionParams(node, isConstructor) {
    this.expect(10);
    this.expressionScope.enter(newParameterDeclarationScope());
    node.params = this.parseBindingList(11, 41, 2 | (isConstructor ? 4 : 0));
    this.expressionScope.exit();
  }
  registerFunctionStatementId(node) {
    if (!node.id) return;
    this.scope.declareName(node.id.name, !this.options.annexB || 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();
    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(Errors.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(Errors.DecoratorConstructor, {
            at: member
          });
        }
      }
    });
    this.state.strict = oldStrict;
    this.next();
    if (decorators.length) {
      throw this.raise(Errors.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(136);
      this.parseClassElementName(method);
      if (isPrivateName) {
        this.pushClassPrivateMethod(classBody, privateMethod, true, false);
        return;
      }
      if (this.isNonstaticConstructor(publicMethod)) {
        this.raise(Errors.ConstructorIsGenerator, {
          at: publicMethod.key
        });
      }
      this.pushClassMethod(classBody, publicMethod, true, false, false, false);
      return;
    }
    const isContextual = tokenIsIdentifier(this.state.type) && !this.state.containsEsc;
    const isPrivate = this.match(136);
    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(Errors.DuplicateConstructor, {
            at: key
          });
        }
        if (isConstructor && this.hasPlugin("typescript") && member.override) {
          this.raise(Errors.OverrideOnConstructor, {
            at: 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(136);
      this.parseClassElementName(method);
      this.parsePostMemberNameModifiers(publicMember);
      if (isPrivate) {
        this.pushClassPrivateMethod(classBody, privateMethod, isGenerator, true);
      } else {
        if (this.isNonstaticConstructor(publicMethod)) {
          this.raise(Errors.ConstructorIsAsync, {
            at: 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(136);
      this.parseClassElementName(publicMethod);
      if (isPrivate) {
        this.pushClassPrivateMethod(classBody, privateMethod, false, false);
      } else {
        if (this.isNonstaticConstructor(publicMethod)) {
          this.raise(Errors.ConstructorIsAccessor, {
            at: 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(136);
      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 === 130 || type === 131) && member.static && value === "prototype") {
      this.raise(Errors.StaticPrototype, {
        at: this.state.startLoc
      });
    }
    if (type === 136) {
      if (value === "constructor") {
        this.raise(Errors.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(Errors.DecoratorStaticBlock, {
        at: member
      });
    }
  }
  pushClassProperty(classBody, prop) {
    if (!prop.computed && (prop.key.name === "constructor" || prop.key.value === "constructor")) {
      this.raise(Errors.ConstructorClassField, {
        at: 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(Errors.ConstructorClassField, {
          at: 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.declareNameFromIdentifier(node.id, bindingType);
      }
    } else {
      if (optionalId || !isStatement) {
        node.id = null;
      } else {
        throw this.raise(Errors.MissingClassName, {
          at: this.state.startLoc
        });
      }
    }
  }
  parseClassSuper(node) {
    node.superClass = this.eat(81) ? this.parseExprSubscripts() : null;
  }
  parseExport(node, decorators) {
    const maybeDefaultIdentifier = this.parseMaybeImportPhase(node, true);
    const hasDefault = this.maybeParseExportDefaultSpecifier(node, maybeDefaultIdentifier);
    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();
      if (decorators) {
        throw this.raise(Errors.UnsupportedDecoratorExport, {
          at: node
        });
      }
      this.parseExportFrom(node, true);
      return this.finishNode(node, "ExportAllDeclaration");
    }
    const hasSpecifiers = this.maybeParseExportNamedSpecifiers(node);
    if (hasDefault && parseAfterDefault && !hasStar && !hasSpecifiers) {
      this.unexpected(null, 5);
    }
    if (hasNamespace && parseAfterNamespace) {
      this.unexpected(null, 97);
    }
    let hasDeclaration;
    if (isFromRequired || hasSpecifiers) {
      hasDeclaration = false;
      if (decorators) {
        throw this.raise(Errors.UnsupportedDecoratorExport, {
          at: node
        });
      }
      this.parseExportFrom(node, isFromRequired);
    } else {
      hasDeclaration = this.maybeParseExportDeclaration(node);
    }
    if (isFromRequired || hasSpecifiers || hasDeclaration) {
      var _node2$declaration;
      const node2 = node;
      this.checkExport(node2, true, false, !!node2.source);
      if (((_node2$declaration = node2.declaration) == null ? void 0 : _node2$declaration.type) === "ClassDeclaration") {
        this.maybeTakeDecorators(decorators, node2.declaration, node2);
      } else if (decorators) {
        throw this.raise(Errors.UnsupportedDecoratorExport, {
          at: node
        });
      }
      return this.finishNode(node2, "ExportNamedDeclaration");
    }
    if (this.eat(65)) {
      const node2 = node;
      const decl = this.parseExportDefaultExpression();
      node2.declaration = decl;
      if (decl.type === "ClassDeclaration") {
        this.maybeTakeDecorators(decorators, decl, node2);
      } else if (decorators) {
        throw this.raise(Errors.UnsupportedDecoratorExport, {
          at: node
        });
      }
      this.checkExport(node2, true, true);
      return this.finishNode(node2, "ExportDefaultDeclaration");
    }
    this.unexpected(null, 5);
  }
  eatExportStar(node) {
    return this.eat(55);
  }
  maybeParseExportDefaultSpecifier(node, maybeDefaultIdentifier) {
    if (maybeDefaultIdentifier || this.isExportDefaultSpecifier()) {
      this.expectPlugin("exportDefaultFrom", maybeDefaultIdentifier == null ? void 0 : maybeDefaultIdentifier.loc.start);
      const id = maybeDefaultIdentifier || this.parseIdentifier(true);
      const specifier = this.startNodeAtNode(id);
      specifier.exported = id;
      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.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.nextTokenInLineStart();
    return this.isUnparsedContextual(next, "function");
  }
  parseExportDefaultExpression() {
    const expr = this.startNode();
    if (this.match(68)) {
      this.next();
      return this.parseFunction(expr, 1 | 4);
    } else if (this.isAsyncFunction()) {
      this.next();
      this.next();
      return this.parseFunction(expr, 1 | 4 | 8);
    }
    if (this.match(80)) {
      return this.parseClass(expr, true, true);
    }
    if (this.match(26)) {
      if (this.hasPlugin("decorators") && this.getPluginOption("decorators", "decoratorsBeforeExport") === true) {
        this.raise(Errors.DecoratorBeforeExport, {
          at: this.state.startLoc
        });
      }
      return this.parseClass(this.maybeTakeDecorators(this.parseDecorators(false), this.startNode()), true, true);
    }
    if (this.match(75) || this.match(74) || this.isLet()) {
      throw this.raise(Errors.UnsupportedDefaultExport, {
        at: this.state.startLoc
      });
    }
    const res = this.parseMaybeAssignAllowIn();
    this.semicolon();
    return res;
  }
  parseExportDeclaration(node) {
    if (this.match(80)) {
      const node = this.parseClass(this.startNode(), true, false);
      return node;
    }
    return this.parseStatementListItem();
  }
  isExportDefaultSpecifier() {
    const {
      type
    } = this.state;
    if (tokenIsIdentifier(type)) {
      if (type === 95 && !this.state.containsEsc || type === 99) {
        return false;
      }
      if ((type === 128 || type === 127) && !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);
      this.maybeParseImportAttributes(node);
      this.checkJSONModuleImport(node);
    } 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") === true) {
          this.raise(Errors.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(Errors.ExportDefaultFromAsIdentifier, {
              at: declaration
            });
          }
        }
      } else if (node.specifiers && node.specifiers.length) {
        for (const specifier of node.specifiers) {
          const {
            exported
          } = specifier;
          const exportName = exported.type === "Identifier" ? exported.name : exported.value;
          this.checkDuplicateExports(specifier, exportName);
          if (!isFrom && specifier.local) {
            const {
              local
            } = specifier;
            if (local.type !== "Identifier") {
              this.raise(Errors.ExportBindingIsString, {
                at: specifier,
                localName: local.value,
                exportName
              });
            } 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);
          }
        }
      }
    }
  }
  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, exportName) {
    if (this.exportedIdentifiers.has(exportName)) {
      if (exportName === "default") {
        this.raise(Errors.DuplicateDefaultExport, {
          at: node
        });
      } else {
        this.raise(Errors.DuplicateExport, {
          at: node,
          exportName
        });
      }
    }
    this.exportedIdentifiers.add(exportName);
  }
  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(128);
      const isString = this.match(131);
      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(131)) {
      const result = this.parseStringLiteral(this.state.value);
      const surrogate = result.value.match(loneSurrogate);
      if (surrogate) {
        this.raise(Errors.ModuleExportNameHasLoneSurrogate, {
          at: result,
          surrogateCharCode: surrogate[0].charCodeAt(0)
        });
      }
      return result;
    }
    return this.parseIdentifier(true);
  }
  isJSONModuleImport(node) {
    if (node.assertions != null) {
      return node.assertions.some(({
        key,
        value
      }) => {
        return value.value === "json" && (key.type === "Identifier" ? key.name === "type" : key.value === "type");
      });
    }
    return false;
  }
  checkImportReflection(node) {
    if (node.module) {
      var _node$assertions;
      if (node.specifiers.length !== 1 || node.specifiers[0].type !== "ImportDefaultSpecifier") {
        this.raise(Errors.ImportReflectionNotBinding, {
          at: node.specifiers[0].loc.start
        });
      }
      if (((_node$assertions = node.assertions) == null ? void 0 : _node$assertions.length) > 0) {
        this.raise(Errors.ImportReflectionHasAssertion, {
          at: node.specifiers[0].loc.start
        });
      }
    }
  }
  checkJSONModuleImport(node) {
    if (this.isJSONModuleImport(node) && node.type !== "ExportAllDeclaration") {
      const {
        specifiers
      } = node;
      if (specifiers != null) {
        const nonDefaultNamedSpecifier = specifiers.find(specifier => {
          let imported;
          if (specifier.type === "ExportSpecifier") {
            imported = specifier.local;
          } else if (specifier.type === "ImportSpecifier") {
            imported = specifier.imported;
          }
          if (imported !== undefined) {
            return imported.type === "Identifier" ? imported.name !== "default" : imported.value !== "default";
          }
        });
        if (nonDefaultNamedSpecifier !== undefined) {
          this.raise(Errors.ImportJSONBindingNotDefault, {
            at: nonDefaultNamedSpecifier.loc.start
          });
        }
      }
    }
  }
  isPotentialImportPhase(isExport) {
    return !isExport && this.isContextual(125);
  }
  applyImportPhase(node, isExport, phase, loc) {
    if (isExport) {
      return;
    }
    if (phase === "module") {
      this.expectPlugin("importReflection", loc);
      node.module = true;
    } else if (this.hasPlugin("importReflection")) {
      node.module = false;
    }
  }
  parseMaybeImportPhase(node, isExport) {
    if (!this.isPotentialImportPhase(isExport)) {
      this.applyImportPhase(node, isExport, null);
      return null;
    }
    const phaseIdentifier = this.parseIdentifier(true);
    const {
      type
    } = this.state;
    const isImportPhase = tokenIsKeywordOrIdentifier(type) ? type !== 97 || this.lookaheadCharCode() === 102 : type !== 12;
    if (isImportPhase) {
      this.resetPreviousIdentifierLeadingComments(phaseIdentifier);
      this.applyImportPhase(node, isExport, phaseIdentifier.name, phaseIdentifier.loc.start);
      return null;
    } else {
      this.applyImportPhase(node, isExport, null);
      return phaseIdentifier;
    }
  }
  isPrecedingIdImportPhase(phase) {
    const {
      type
    } = this.state;
    return tokenIsIdentifier(type) ? type !== 97 || this.lookaheadCharCode() === 102 : type !== 12;
  }
  parseImport(node) {
    if (this.match(131)) {
      return this.parseImportSourceAndAttributes(node);
    }
    return this.parseImportSpecifiersAndAfter(node, this.parseMaybeImportPhase(node, false));
  }
  parseImportSpecifiersAndAfter(node, maybeDefaultIdentifier) {
    node.specifiers = [];
    const hasDefault = this.maybeParseDefaultImportSpecifier(node, maybeDefaultIdentifier);
    const parseNext = !hasDefault || this.eat(12);
    const hasStar = parseNext && this.maybeParseStarImportSpecifier(node);
    if (parseNext && !hasStar) this.parseNamedImportSpecifiers(node);
    this.expectContextual(97);
    return this.parseImportSourceAndAttributes(node);
  }
  parseImportSourceAndAttributes(node) {
    var _node$specifiers;
    (_node$specifiers = node.specifiers) != null ? _node$specifiers : node.specifiers = [];
    node.source = this.parseImportSource();
    this.maybeParseImportAttributes(node);
    this.checkImportReflection(node);
    this.checkJSONModuleImport(node);
    this.semicolon();
    return this.finishNode(node, "ImportDeclaration");
  }
  parseImportSource() {
    if (!this.match(131)) this.unexpected();
    return this.parseExprAtom();
  }
  parseImportSpecifierLocal(node, specifier, type) {
    specifier.local = this.parseIdentifier();
    node.specifiers.push(this.finishImportSpecifier(specifier, type));
  }
  finishImportSpecifier(specifier, type, bindingType = BIND_LEXICAL) {
    this.checkLVal(specifier.local, {
      in: {
        type
      },
      binding: bindingType
    });
    return this.finishNode(specifier, type);
  }
  parseImportAttributes() {
    this.expect(5);
    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(Errors.ModuleAttributesWithDuplicateKeys, {
          at: this.state.startLoc,
          key: keyName
        });
      }
      attrNames.add(keyName);
      if (this.match(131)) {
        node.key = this.parseStringLiteral(keyName);
      } else {
        node.key = this.parseIdentifier(true);
      }
      this.expect(14);
      if (!this.match(131)) {
        throw this.raise(Errors.ModuleAttributeInvalidValue, {
          at: this.state.startLoc
        });
      }
      node.value = this.parseStringLiteral(this.state.value);
      attrs.push(this.finishNode(node, "ImportAttribute"));
    } while (this.eat(12));
    this.expect(8);
    return attrs;
  }
  parseModuleAttributes() {
    const attrs = [];
    const attributes = new Set();
    do {
      const node = this.startNode();
      node.key = this.parseIdentifier(true);
      if (node.key.name !== "type") {
        this.raise(Errors.ModuleAttributeDifferentFromType, {
          at: node.key
        });
      }
      if (attributes.has(node.key.name)) {
        this.raise(Errors.ModuleAttributesWithDuplicateKeys, {
          at: node.key,
          key: node.key.name
        });
      }
      attributes.add(node.key.name);
      this.expect(14);
      if (!this.match(131)) {
        throw this.raise(Errors.ModuleAttributeInvalidValue, {
          at: this.state.startLoc
        });
      }
      node.value = this.parseStringLiteral(this.state.value);
      attrs.push(this.finishNode(node, "ImportAttribute"));
    } while (this.eat(12));
    return attrs;
  }
  maybeParseImportAttributes(node) {
    let attributes;
    let useWith = false;
    if (this.match(76)) {
      if (this.hasPrecedingLineBreak() && this.lookaheadCharCode() === 40) {
        return;
      }
      this.next();
      {
        if (this.hasPlugin("moduleAttributes")) {
          attributes = this.parseModuleAttributes();
        } else {
          this.expectImportAttributesPlugin();
          attributes = this.parseImportAttributes();
        }
      }
      useWith = true;
    } else if (this.isContextual(94) && !this.hasPrecedingLineBreak()) {
      if (this.hasPlugin("importAttributes")) {
        if (this.getPluginOption("importAttributes", "deprecatedAssertSyntax") !== true) {
          this.raise(Errors.ImportAttributesUseAssert, {
            at: this.state.startLoc
          });
        }
        this.addExtra(node, "deprecatedAssertSyntax", true);
      } else {
        this.expectOnePlugin(["importAttributes", "importAssertions"]);
      }
      this.next();
      attributes = this.parseImportAttributes();
    } else if (this.hasPlugin("importAttributes") || this.hasPlugin("importAssertions")) {
      attributes = [];
    } else {
      if (this.hasPlugin("moduleAttributes")) {
        attributes = [];
      } else return;
    }
    if (!useWith && this.hasPlugin("importAssertions")) {
      node.assertions = attributes;
    } else {
      node.attributes = attributes;
    }
  }
  maybeParseDefaultImportSpecifier(node, maybeDefaultIdentifier) {
    if (maybeDefaultIdentifier) {
      const specifier = this.startNodeAtNode(maybeDefaultIdentifier);
      specifier.local = maybeDefaultIdentifier;
      node.specifiers.push(this.finishImportSpecifier(specifier, "ImportDefaultSpecifier"));
      return true;
    } else if (tokenIsKeywordOrIdentifier(this.state.type)) {
      this.parseImportSpecifierLocal(node, this.startNode(), "ImportDefaultSpecifier");
      return true;
    }
    return false;
  }
  maybeParseStarImportSpecifier(node) {
    if (this.match(55)) {
      const specifier = this.startNode();
      this.next();
      this.expectContextual(93);
      this.parseImportSpecifierLocal(node, specifier, "ImportNamespaceSpecifier");
      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(Errors.DestructureNamedImport, {
            at: this.state.startLoc
          });
        }
        this.expect(12);
        if (this.eat(8)) break;
      }
      const specifier = this.startNode();
      const importedIsString = this.match(131);
      const isMaybeTypeOnly = this.isContextual(128);
      specifier.imported = this.parseModuleExportName();
      const importSpecifier = this.parseImportSpecifier(specifier, importedIsString, node.importKind === "type" || node.importKind === "typeof", isMaybeTypeOnly, undefined);
      node.specifiers.push(importSpecifier);
    }
  }
  parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, bindingType) {
    if (this.eatContextual(93)) {
      specifier.local = this.parseIdentifier();
    } else {
      const {
        imported
      } = specifier;
      if (importedIsString) {
        throw this.raise(Errors.ImportBindingIsString, {
          at: specifier,
          importName: imported.value
        });
      }
      this.checkReservedWord(imported.name, specifier.loc.start, true, true);
      if (!specifier.local) {
        specifier.local = cloneIdentifier(imported);
      }
    }
    return this.finishImportSpecifier(specifier, "ImportSpecifier", bindingType);
  }
  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
�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������lib/index.js.map������������������������������������������������������������������������������������0000644�����������������00005125066�15120211212�0007535 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������{"version":3,"file":"index.js","sources":["../src/util/location.ts","../src/parse-error/credentials.ts","../src/parse-error/module-errors.ts","../src/parse-error/to-node-description.ts","../src/parse-error/standard-errors.ts","../src/parse-error/strict-mode-errors.ts","../src/parse-error/pipeline-operator-errors.ts","../src/parse-error.ts","../src/plugins/estree.ts","../src/tokenizer/context.ts","../src/tokenizer/types.ts","../../babel-helper-validator-identifier/src/identifier.ts","../../babel-helper-validator-identifier/src/keyword.ts","../src/util/identifier.ts","../src/util/scopeflags.ts","../src/util/scope.ts","../src/plugins/flow/scope.ts","../src/parser/base.ts","../src/parser/comments.ts","../src/util/whitespace.ts","../src/tokenizer/state.ts","../../babel-helper-string-parser/src/index.ts","../src/tokenizer/index.ts","../src/util/class-scope.ts","../src/util/expression-scope.ts","../src/util/production-parameter.ts","../src/parser/util.ts","../src/parser/node.ts","../src/plugins/flow/index.ts","../src/plugins/jsx/xhtml.ts","../src/plugins/jsx/index.ts","../src/plugins/typescript/scope.ts","../src/parser/lval.ts","../src/plugins/typescript/index.ts","../src/plugins/placeholders.ts","../src/plugins/v8intrinsic.ts","../src/plugin-utils.ts","../src/options.ts","../src/parser/expression.ts","../src/parser/statement.ts","../src/parser/index.ts","../src/index.ts"],"sourcesContent":["export 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 | undefined | null;\n\n  constructor(start: Position, end?: Position) {\n    this.start = start;\n    // (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 */\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","export const enum ParseErrorCode {\n  SyntaxError = \"BABEL_PARSER_SYNTAX_ERROR\",\n  SourceTypeModuleError = \"BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED\",\n}\n\nexport type SyntaxPlugin =\n  | \"flow\"\n  | \"typescript\"\n  | \"jsx\"\n  | \"pipelineOperator\"\n  | \"placeholders\";\n\nexport type ToMessage<ErrorDetails> = (self: ErrorDetails) => string;\n\nexport type ParseErrorCredentials<ErrorDetails> = {\n  code: ParseErrorCode;\n  reasonCode: string;\n  syntaxPlugin?: SyntaxPlugin;\n  toMessage: ToMessage<ErrorDetails>;\n};\n\nconst reflect = (keys: string[], last = keys.length - 1) => ({\n  get(this: unknown): unknown {\n    return keys.reduce(\n      (object, key) =>\n        // @ts-expect-error key should index object\n        object[key],\n      this,\n    );\n  },\n  set(this: unknown, value: unknown) {\n    keys.reduce(\n      // @ts-expect-error key should index item\n      (item, key, i) => (i === last ? (item[key] = value) : item[key]),\n      this,\n    );\n  },\n});\n\nconst instantiate = <T>(\n  constructor: new () => T,\n  properties: any,\n  descriptors: any,\n) =>\n  Object.keys(descriptors)\n    .map(key => [key, descriptors[key]])\n    .filter(([, descriptor]) => !!descriptor)\n    .map(([key, descriptor]) => [\n      key,\n      typeof descriptor === \"function\"\n        ? { value: descriptor, enumerable: false }\n        : typeof descriptor.reflect === \"string\"\n        ? { ...descriptor, ...reflect(descriptor.reflect.split(\".\")) }\n        : descriptor,\n    ])\n    .reduce(\n      (instance, [key, descriptor]) =>\n        Object.defineProperty(instance, key, {\n          configurable: true,\n          ...descriptor,\n        }),\n      Object.assign(new constructor(), properties),\n    );\n\nexport { instantiate };\n","import { ParseErrorCode } from \"../parse-error\";\n\nexport default {\n  ImportMetaOutsideModule: {\n    message: `import.meta may appear only with 'sourceType: \"module\"'`,\n    code: ParseErrorCode.SourceTypeModuleError,\n  },\n  ImportOutsideModule: {\n    message: `'import' and 'export' may appear only with 'sourceType: \"module\"'`,\n    code: ParseErrorCode.SourceTypeModuleError,\n  },\n};\n","const NodeDescriptions = {\n  ArrayPattern: \"array destructuring pattern\",\n  AssignmentExpression: \"assignment expression\",\n  AssignmentPattern: \"assignment expression\",\n  ArrowFunctionExpression: \"arrow function expression\",\n  ConditionalExpression: \"conditional expression\",\n  CatchClause: \"catch clause\",\n  ForOfStatement: \"for-of statement\",\n  ForInStatement: \"for-in statement\",\n  ForStatement: \"for-loop\",\n  FormalParameters: \"function parameter list\",\n  Identifier: \"identifier\",\n  ImportSpecifier: \"import specifier\",\n  ImportDefaultSpecifier: \"import default specifier\",\n  ImportNamespaceSpecifier: \"import namespace specifier\",\n  ObjectPattern: \"object destructuring pattern\",\n  ParenthesizedExpression: \"parenthesized expression\",\n  RestElement: \"rest element\",\n  UpdateExpression: {\n    true: \"prefix operation\",\n    false: \"postfix operation\",\n  },\n  VariableDeclarator: \"variable declaration\",\n  YieldExpression: \"yield expression\",\n};\n\ntype NodeTypesWithDescriptions = keyof Omit<\n  typeof NodeDescriptions,\n  \"UpdateExpression\"\n>;\n\ntype NodeWithDescription =\n  | {\n      type: \"UpdateExpression\";\n      prefix: boolean;\n    }\n  | {\n      type: NodeTypesWithDescriptions;\n    };\n\n// @ts-expect-error prefix is specified only when type is UpdateExpression\n// eslint-disable-next-line no-confusing-arrow\nconst toNodeDescription = ({ type, prefix }: NodeWithDescription) =>\n  type === \"UpdateExpression\"\n    ? NodeDescriptions.UpdateExpression[String(prefix) as \"true\" | \"false\"]\n    : NodeDescriptions[type];\n\nexport default toNodeDescription;\n","import toNodeDescription from \"./to-node-description\";\n\nexport type LValAncestor =\n  | { type: \"UpdateExpression\"; prefix: boolean }\n  | {\n      type:\n        | \"ArrayPattern\"\n        | \"AssignmentExpression\"\n        | \"CatchClause\"\n        | \"ForOfStatement\"\n        | \"FormalParameters\"\n        | \"ForInStatement\"\n        | \"ForStatement\"\n        | \"ImportSpecifier\"\n        | \"ImportNamespaceSpecifier\"\n        | \"ImportDefaultSpecifier\"\n        | \"ParenthesizedExpression\"\n        | \"ObjectPattern\"\n        | \"RestElement\"\n        | \"VariableDeclarator\";\n    };\n\nexport default {\n  AccessorIsGenerator: ({ kind }: { kind: \"get\" | \"set\" }) =>\n    `A ${kind}ter 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  AwaitUsingNotInAsyncContext:\n    \"'await using' is only allowed within async functions and at the top levels of modules.\",\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' accessor must not have any formal parameters.\",\n  BadSetterArity: \"A 'set' accessor must have exactly one formal parameter.\",\n  BadSetterRestParameter:\n    \"A 'set' accessor 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: ({\n    kind,\n  }: {\n    kind: \"const\" | \"destructuring\";\n  }) => `Missing initializer in ${kind} declaration.`,\n  DecoratorArgumentsOutsideParentheses:\n    \"Decorator arguments must be moved inside parentheses: use '@(decorator(args))' instead of '@(decorator)(args)'.\",\n  DecoratorBeforeExport:\n    \"Decorators must be placed *before* the 'export' keyword. Remove the 'decoratorsBeforeExport: true' option to use the 'export @decorator class {}' syntax.\",\n  DecoratorsBeforeAfterExport:\n    \"Decorators can be placed *either* before or after the 'export' keyword, but not in both locations at the same time.\",\n  DecoratorConstructor:\n    \"Decorators can't be used with a constructor. Did you mean '@dec class { ... }'?\",\n  DecoratorExportClass:\n    \"Decorators must be placed *after* the 'export' keyword. Remove the 'decoratorsBeforeExport: false' option to use the '@decorator export class {}' syntax.\",\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: ({ exportName }: { exportName: string }) =>\n    `\\`${exportName}\\` 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    localName,\n    exportName,\n  }: {\n    localName: string;\n    exportName: string;\n  }) =>\n    `A string literal cannot be used as an exported binding without \\`from\\`.\\n- Did you mean \\`export { '${localName}' as '${exportName}' } from 'some-module'\\`?`,\n  ExportDefaultFromAsIdentifier:\n    \"'from' is not allowed as an identifier after 'export default'.\",\n\n  ForInOfLoopInitializer: ({\n    type,\n  }: {\n    type: \"ForInStatement\" | \"ForOfStatement\";\n  }) =>\n    `'${\n      type === \"ForInStatement\" ? \"for-in\" : \"for-of\"\n    }' loop variable declaration may not have an initializer.`,\n  ForInUsing: \"For-in loop may not start with 'using' declaration.\",\n\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\n  IllegalBreakContinue: ({\n    type,\n  }: {\n    type: \"BreakStatement\" | \"ContinueStatement\";\n  }) => `Unsyntactic ${type === \"BreakStatement\" ? \"break\" : \"continue\"}.`,\n\n  IllegalLanguageModeDirective:\n    \"Illegal 'use strict' directive in function with non-simple parameter list.\",\n  IllegalReturn: \"'return' outside of function.\",\n  ImportAttributesUseAssert:\n    \"The `assert` keyword in import attributes is deprecated and it has been replaced by the `with` keyword. You can enable the `deprecatedAssertSyntax: true` option in the import attributes plugin to suppress this error.\",\n  ImportBindingIsString: ({ importName }: { importName: string }) =>\n    `A string literal cannot be used as an imported binding.\\n- Did you mean \\`import { \"${importName}\" as foo }\\`?`,\n  ImportCallArgumentTrailingComma:\n    \"Trailing comma is disallowed inside import(...) arguments.\",\n  ImportCallArity: ({ maxArgumentCount }: { maxArgumentCount: 1 | 2 }) =>\n    `\\`import()\\` requires exactly ${\n      maxArgumentCount === 1 ? \"one argument\" : \"one or two arguments\"\n    }.`,\n  ImportCallNotNewExpression: \"Cannot use new with import(...).\",\n  ImportCallSpreadArgument: \"`...` is not allowed in `import()`.\",\n  ImportJSONBindingNotDefault:\n    \"A JSON module can only be imported with `default`.\",\n  ImportReflectionHasAssertion: \"`import module x` cannot have assertions.\",\n  ImportReflectionNotBinding:\n    'Only `import module x from \"./module\"` is valid.',\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: ({ radix }: { radix: number }) =>\n    `Expected number in radix ${radix}.`,\n  InvalidEscapeSequence: \"Bad character escape sequence.\",\n  InvalidEscapeSequenceTemplate: \"Invalid escape sequence in template.\",\n  InvalidEscapedReservedWord: ({ reservedWord }: { reservedWord: string }) =>\n    `Escape sequence in keyword ${reservedWord}.`,\n  InvalidIdentifier: ({ identifierName }: { identifierName: string }) =>\n    `Invalid identifier ${identifierName}.`,\n  InvalidLhs: ({ ancestor }: { ancestor: LValAncestor }) =>\n    `Invalid left-hand side in ${toNodeDescription(ancestor)}.`,\n  InvalidLhsBinding: ({ ancestor }: { ancestor: LValAncestor }) =>\n    `Binding invalid left-hand side in ${toNodeDescription(ancestor)}.`,\n  InvalidNumber: \"Invalid number.\",\n  InvalidOrMissingExponent:\n    \"Floating-point numbers require a valid exponent after the 'e'.\",\n  InvalidOrUnexpectedToken: ({ unexpected }: { unexpected: string }) =>\n    `Unexpected character '${unexpected}'.`,\n  InvalidParenthesizedAssignment: \"Invalid parenthesized assignment pattern.\",\n  InvalidPrivateFieldResolution: ({\n    identifierName,\n  }: {\n    identifierName: string;\n  }) => `Private name #${identifierName} 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: ({ labelName }: { labelName: string }) =>\n    `Label '${labelName}' 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  MissingPlugin: ({ missingPlugin }: { missingPlugin: [string] }) =>\n    `This experimental syntax requires enabling the parser plugin: ${missingPlugin\n      .map(name => JSON.stringify(name))\n      .join(\", \")}.`,\n  // FIXME: Would be nice to make this \"missingPlugins\" instead.\n  // Also, seems like we can drop the \"(s)\" from the message and just make it \"s\".\n  MissingOneOfPlugins: ({ missingPlugin }: { missingPlugin: string[] }) =>\n    `This experimental syntax requires enabling one of the following parser plugin(s): ${missingPlugin\n      .map(name => JSON.stringify(name))\n      .join(\", \")}.`,\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: ({ key }: { key: string }) =>\n    `Duplicate key \"${key}\" is not allowed in module attributes.`,\n  ModuleExportNameHasLoneSurrogate: ({\n    surrogateCharCode,\n  }: {\n    surrogateCharCode: number;\n  }) =>\n    `An export name cannot include a lone surrogate, found '\\\\u${surrogateCharCode.toString(\n      16,\n    )}'.`,\n  ModuleExportUndefined: ({ localName }: { localName: string }) =>\n    `Export '${localName}' 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  PrivateInExpectedIn: ({ identifierName }: { identifierName: string }) =>\n    `Private names are only allowed in property accesses (\\`obj.#${identifierName}\\`) or in \\`in\\` expressions (\\`#${identifierName} in obj\\`).`,\n  PrivateNameRedeclaration: ({ identifierName }: { identifierName: string }) =>\n    `Duplicate private name #${identifierName}.`,\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 or inside a block.\",\n  SloppyFunctionAnnexB:\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  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: ({ keyword }: { keyword: string }) =>\n    `Unexpected keyword '${keyword}'.`,\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: ({ reservedWord }: { reservedWord: string }) =>\n    `Unexpected reserved word '${reservedWord}'.`,\n  UnexpectedSuper: \"'super' is only allowed in object methods and classes.\",\n  UnexpectedToken: ({\n    expected,\n    unexpected,\n  }: {\n    expected?: string | null;\n    unexpected?: string | null;\n  }) =>\n    `Unexpected token${unexpected ? ` '${unexpected}'.` : \"\"}${\n      expected ? `, expected \"${expected}\"` : \"\"\n    }`,\n  UnexpectedTokenUnaryExponentiation:\n    \"Illegal expression. Wrap left hand side or entire exponentiation in parentheses.\",\n  UnexpectedUsingDeclaration:\n    \"Using declaration cannot appear in the top level when source type is `script`.\",\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: ({\n    target,\n    onlyValidPropertyName,\n  }: {\n    target: string;\n    onlyValidPropertyName: string;\n  }) =>\n    `The only valid meta property for ${target} is ${target}.${onlyValidPropertyName}.`,\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  UsingDeclarationHasBindingPattern:\n    \"Using declaration cannot have destructuring patterns.\",\n  VarRedeclaration: ({ identifierName }: { identifierName: string }) =>\n    `Identifier '${identifierName}' 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","export default {\n  StrictDelete: \"Deleting local variable in strict mode.\",\n\n  // `referenceName` is the StringValue[1] of an IdentifierReference[2], which\n  // is represented as just an `Identifier`[3] in the Babel AST.\n  // 1. https://tc39.es/ecma262/#sec-static-semantics-stringvalue\n  // 2. https://tc39.es/ecma262/#prod-IdentifierReference\n  // 3. https://github.com/babel/babel/blob/main/packages/babel-parser/ast/spec.md#identifier\n  StrictEvalArguments: ({ referenceName }: { referenceName: string }) =>\n    `Assigning to '${referenceName}' in strict mode.`,\n\n  // `bindingName` is the StringValue[1] of a BindingIdentifier[2], which is\n  // represented as just an `Identifier`[3] in the Babel AST.\n  // 1. https://tc39.es/ecma262/#sec-static-semantics-stringvalue\n  // 2. https://tc39.es/ecma262/#prod-BindingIdentifier\n  // 3. https://github.com/babel/babel/blob/main/packages/babel-parser/ast/spec.md#identifier\n  StrictEvalArgumentsBinding: ({ bindingName }: { bindingName: string }) =>\n    `Binding '${bindingName}' in strict mode.`,\n\n  StrictFunction:\n    \"In strict mode code, functions can only be declared at top level or inside a block.\",\n\n  StrictNumericEscape: \"The only valid numeric escape in strict mode is '\\\\0'.\",\n\n  StrictOctalLiteral: \"Legacy octal literals are not allowed in strict mode.\",\n\n  StrictWith: \"'with' in strict mode.\",\n};\n","import toNodeDescription from \"./to-node-description\";\n\nexport const UnparenthesizedPipeBodyDescriptions = new Set([\n  \"ArrowFunctionExpression\",\n  \"AssignmentExpression\",\n  \"ConditionalExpression\",\n  \"YieldExpression\",\n] as const);\n\ntype GetSetMemberType<T extends Set<any>> = T extends Set<infer M>\n  ? M\n  : unknown;\n\ntype UnparenthesizedPipeBodyTypes = GetSetMemberType<\n  typeof UnparenthesizedPipeBodyDescriptions\n>;\n\nexport default {\n  // This error is only used by the smart-mix proposal\n  PipeBodyIsTighter:\n    \"Unexpected yield after pipeline body; any yield 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: ({ token }: { token: string }) =>\n    `Invalid topic token ${token}. In order to use ${token} as a topic reference, the pipelineOperator plugin must be configured with { \"proposal\": \"hack\", \"topicToken\": \"${token}\" }.`,\n  PipeTopicUnused:\n    \"Hack-style pipe body does not contain a topic reference; Hack-style pipes must use topic at least once.\",\n  PipeUnparenthesizedBody: ({ type }: { type: UnparenthesizedPipeBodyTypes }) =>\n    `Hack-style pipe body cannot be an unparenthesized ${toNodeDescription({\n      type,\n    })}; 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","import { Position } from \"./util/location\";\nimport {\n  instantiate,\n  ParseErrorCode,\n  type ParseErrorCredentials,\n  type ToMessage,\n  type SyntaxPlugin,\n} from \"./parse-error/credentials\";\nimport type { Undone } from \"./parser/node\";\nimport type { Node } from \"./types\";\n\n// Babel uses \"normal\" SyntaxErrors for it's errors, but adds some extra\n// functionality. This functionality is defined in the\n// `ParseErrorSpecification` interface below. We may choose to change to someday\n// give our errors their own full-blown class, but until then this allow us to\n// keep all the desirable properties of SyntaxErrors (like their name in stack\n// traces, etc.), and also allows us to punt on any publicly facing\n// class-hierarchy decisions until Babel 8.\ninterface ParseErrorSpecification<ErrorDetails> {\n  // Look, these *could* be readonly, but then Flow complains when we initially\n  // set them. We could do a whole dance and make a special interface that's not\n  // readonly for when we create the error, then cast it to the readonly\n  // interface for public use, but the previous implementation didn't have them\n  // as readonly, so let's just not worry about it for now.\n  code: ParseErrorCode;\n  reasonCode: string;\n  syntaxPlugin?: SyntaxPlugin;\n  missingPlugin?: string | string[];\n  loc: Position;\n  details: ErrorDetails;\n\n  // We should consider removing this as it now just contains the same\n  // information as `loc.index`.\n  // pos: number;\n}\n\nexport type ParseError<ErrorDetails> = SyntaxError &\n  ParseErrorSpecification<ErrorDetails>;\n\n// By `ParseErrorConstructor`, we mean something like the new-less style\n// `ErrorConstructor`[1], since `ParseError`'s are not themselves actually\n// separate classes from `SyntaxError`'s.\n//\n// 1. https://github.com/microsoft/TypeScript/blob/v4.5.5/lib/lib.es5.d.ts#L1027\nexport type ParseErrorConstructor<ErrorDetails> = (a: {\n  loc: Position;\n  details: ErrorDetails;\n}) => ParseError<ErrorDetails>;\n\nfunction toParseErrorConstructor<ErrorDetails extends object>({\n  toMessage,\n  ...properties\n}: ParseErrorCredentials<ErrorDetails>): ParseErrorConstructor<ErrorDetails> {\n  type ConstructorArgument = {\n    loc: Position;\n    details: ErrorDetails;\n  };\n\n  return function constructor({ loc, details }: ConstructorArgument) {\n    return instantiate(\n      SyntaxError,\n      { ...properties, loc },\n      {\n        clone(\n          overrides: {\n            loc?: Position;\n            details?: ErrorDetails;\n          } = {},\n        ) {\n          const loc = (overrides.loc || {}) as Partial<Position>;\n          return constructor({\n            loc: new Position(\n              \"line\" in loc ? loc.line : this.loc.line,\n              \"column\" in loc ? loc.column : this.loc.column,\n              \"index\" in loc ? loc.index : this.loc.index,\n            ),\n            details: { ...this.details, ...overrides.details },\n          });\n        },\n        details: { value: details, enumerable: false },\n        message: {\n          get(this: ConstructorArgument): string {\n            return `${toMessage(this.details)} (${this.loc.line}:${\n              this.loc.column\n            })`;\n          },\n          set(value: string) {\n            Object.defineProperty(this, \"message\", { value });\n          },\n        },\n        pos: { reflect: \"loc.index\", enumerable: true },\n        missingPlugin: \"missingPlugin\" in details && {\n          reflect: \"details.missingPlugin\",\n          enumerable: true,\n        },\n      },\n    ) as ParseError<ErrorDetails>;\n  };\n}\n\ntype ParseErrorTemplate =\n  | string\n  | ToMessage<any>\n  | { message: string | ToMessage<any> };\n\ntype ParseErrorTemplates = { [reasonCode: string]: ParseErrorTemplate };\n\n// This is the templated form of `ParseErrorEnum`.\n//\n// Note: We could factor out the return type calculation into something like\n// `ParseErrorConstructor<T extends ParseErrorTemplates>`, and then we could\n// reuse it in the non-templated form of `ParseErrorEnum`, but TypeScript\n// doesn't seem to drill down that far when showing you the computed type of\n// an object in an editor, so we'll leave it inlined for now.\nexport function ParseErrorEnum(a: TemplateStringsArray): <\n  T extends ParseErrorTemplates,\n>(\n  parseErrorTemplates: T,\n) => {\n  [K in keyof T]: ParseErrorConstructor<\n    T[K] extends { message: string | ToMessage<any> }\n      ? T[K][\"message\"] extends ToMessage<any>\n        ? Parameters<T[K][\"message\"]>[0]\n        : {}\n      : T[K] extends ToMessage<any>\n      ? Parameters<T[K]>[0]\n      : {}\n  >;\n};\n\nexport function ParseErrorEnum<T extends ParseErrorTemplates>(\n  parseErrorTemplates: T,\n  syntaxPlugin?: SyntaxPlugin,\n): {\n  [K in keyof T]: ParseErrorConstructor<\n    T[K] extends { message: string | ToMessage<any> }\n      ? T[K][\"message\"] extends ToMessage<any>\n        ? Parameters<T[K][\"message\"]>[0]\n        : {}\n      : T[K] extends ToMessage<any>\n      ? Parameters<T[K]>[0]\n      : {}\n  >;\n};\n\n// You call `ParseErrorEnum` with a mapping from `ReasonCode`'s to either:\n//\n// 1. a static error message,\n// 2. `toMessage` functions that define additional necessary `details` needed by\n//    the `ParseError`, or\n// 3. Objects that contain a `message` of one of the above and overridden `code`\n//    and/or `reasonCode`:\n//\n// ParseErrorEnum `optionalSyntaxPlugin` ({\n//   ErrorWithStaticMessage: \"message\",\n//   ErrorWithDynamicMessage: ({ type } : { type: string }) => `${type}`),\n//   ErrorWithOverriddenCodeAndOrReasonCode: {\n//     message: ({ type }: { type: string }) => `${type}`),\n//     code: ParseErrorCode.SourceTypeModuleError,\n//     ...(BABEL_8_BREAKING ? { } : { reasonCode: \"CustomErrorReasonCode\" })\n//   }\n// });\n//\nexport function ParseErrorEnum(\n  argument: TemplateStringsArray | ParseErrorTemplates,\n  syntaxPlugin?: SyntaxPlugin,\n) {\n  // If the first parameter is an array, that means we were called with a tagged\n  // template literal. Extract the syntaxPlugin from this, and call again in\n  // the \"normalized\" form.\n  if (Array.isArray(argument)) {\n    return (parseErrorTemplates: ParseErrorTemplates) =>\n      ParseErrorEnum(parseErrorTemplates, argument[0]);\n  }\n\n  const ParseErrorConstructors = {} as Record<\n    string,\n    ParseErrorConstructor<unknown>\n  >;\n\n  for (const reasonCode of Object.keys(argument)) {\n    const template = (argument as ParseErrorTemplates)[reasonCode];\n    const { message, ...rest } =\n      typeof template === \"string\"\n        ? { message: () => template }\n        : typeof template === \"function\"\n        ? { message: template }\n        : template;\n    const toMessage = typeof message === \"string\" ? () => message : message;\n\n    ParseErrorConstructors[reasonCode] = toParseErrorConstructor({\n      code: ParseErrorCode.SyntaxError,\n      reasonCode,\n      toMessage,\n      ...(syntaxPlugin ? { syntaxPlugin } : {}),\n      ...rest,\n    });\n  }\n\n  return ParseErrorConstructors;\n}\n\nexport type RaiseProperties<ErrorDetails> = {\n  at: Position | Undone<Node>;\n} & ErrorDetails;\n\nimport ModuleErrors from \"./parse-error/module-errors\";\nimport StandardErrors from \"./parse-error/standard-errors\";\nimport StrictModeErrors from \"./parse-error/strict-mode-errors\";\nimport PipelineOperatorErrors from \"./parse-error/pipeline-operator-errors\";\n\nexport const Errors = {\n  ...ParseErrorEnum(ModuleErrors),\n  ...ParseErrorEnum(StandardErrors),\n  ...ParseErrorEnum(StrictModeErrors),\n  ...ParseErrorEnum`pipelineOperator`(PipelineOperatorErrors),\n};\n\nexport type { LValAncestor } from \"./parse-error/standard-errors\";\n\nexport * from \"./parse-error/credentials\";\n","import type { TokenType } from \"../tokenizer/types\";\nimport type Parser from \"../parser\";\nimport type { ExpressionErrors } from \"../parser/util\";\nimport type * as N from \"../types\";\nimport type { Node as NodeType, NodeBase, File } from \"../types\";\nimport type { Position } from \"../util/location\";\nimport { Errors } from \"../parse-error\";\nimport type { Undone } from \"../parser/node\";\nimport type { BindingTypes } from \"../util/scopeflags\";\n\nconst { defineProperty } = Object;\nconst toUnenumerable = (object: any, key: string) =>\n  defineProperty(object, key, { enumerable: false, value: object[key] });\n\nfunction toESTreeLocation(node: any) {\n  node.loc.start && toUnenumerable(node.loc.start, \"index\");\n  node.loc.end && toUnenumerable(node.loc.end, \"index\");\n\n  return node;\n}\n\nexport default (superClass: typeof Parser) =>\n  class ESTreeParserMixin extends superClass implements Parser {\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    // @ts-expect-error ESTree plugin changes node types\n    parseRegExpLiteral({ pattern, flags }): N.EstreeRegExpLiteral {\n      let regex: RegExp | null = 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<N.EstreeRegExpLiteral>(regex);\n      node.regex = { pattern, flags };\n\n      return node;\n    }\n\n    // @ts-expect-error ESTree plugin changes node types\n    parseBigIntLiteral(value: any): N.Node {\n      // https://github.com/estree/estree/blob/master/es2020.md#bigintliteral\n      let bigInt: BigInt | null;\n      try {\n        bigInt = BigInt(value);\n      } catch {\n        bigInt = null;\n      }\n      const node = this.estreeParseLiteral<N.EstreeBigIntLiteral>(bigInt);\n      node.bigint = String(node.value || value);\n\n      return node;\n    }\n\n    // @ts-expect-error ESTree plugin changes node types\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 = null;\n      const node = this.estreeParseLiteral(decimal);\n      node.decimal = String(node.value || value);\n\n      return node;\n    }\n\n    estreeParseLiteral<T extends N.Node>(value: any) {\n      // @ts-expect-error ESTree plugin changes node types\n      return this.parseLiteral<T>(value, \"Literal\");\n    }\n\n    // @ts-expect-error ESTree plugin changes node types\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    // @ts-expect-error ESTree plugin changes node types\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    // Cast a Directive to an ExpressionStatement. Mutates the input Directive.\n    directiveToStmt(directive: N.Directive): N.ExpressionStatement {\n      const expression = directive.value as any as N.EstreeLiteral;\n      delete directive.value;\n\n      expression.type = \"Literal\";\n      // @ts-expect-error N.EstreeLiteral.raw is not defined.\n      expression.raw = expression.extra.raw;\n      expression.value = expression.extra.expressionValue;\n\n      const stmt = directive as any as N.ExpressionStatement;\n      stmt.type = \"ExpressionStatement\";\n      stmt.expression = expression;\n      // @ts-expect-error N.ExpressionStatement.directive is not defined\n      stmt.directive = expression.extra.rawValue;\n\n      delete expression.extra;\n\n      return stmt;\n    }\n\n    // ==================================\n    // Overrides\n    // ==================================\n\n    initFunction(node: N.BodilessFunctionOrMethodBase, isAsync: boolean): 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        // @ts-expect-error plugin typings\n        this.checkDeclaration((node as unknown as N.EstreeProperty).value);\n      } else {\n        super.checkDeclaration(node);\n      }\n    }\n\n    getObjectOrClassMethodParams(method: N.ObjectMethod | N.ClassMethod) {\n      return (method as any as N.EstreeProperty | N.EstreeMethodDefinition)\n        .value.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      allowDirectives: boolean | undefined | null,\n      topLevel: boolean,\n      end: TokenType,\n      afterBlockParse?: (hasStrictModeDirective: boolean) => void,\n    ): void {\n      super.parseBlockBody(\n        node,\n        allowDirectives,\n        topLevel,\n        end,\n        afterBlockParse,\n      );\n\n      const directiveStatements = node.directives.map(d =>\n        this.directiveToStmt(d),\n      );\n      // @ts-expect-error estree plugin typings\n      node.body = directiveStatements.concat(node.body);\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        // @ts-expect-error mutate AST types\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 as any;\n      delete node.id;\n      // @ts-expect-error mutate AST types\n      node.name = name;\n      // @ts-expect-error mutate AST types\n      node.type = \"PrivateIdentifier\";\n      return node as unknown as N.EstreePrivateIdentifier;\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    // @ts-expect-error plugin may override interfaces\n    parseLiteral<T extends N.Literal>(value: any, type: T[\"type\"]): T {\n      const node = super.parseLiteral<T>(value, type);\n      // @ts-expect-error mutating AST types\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 | null,\n      isMethod: boolean = false,\n    ): void {\n      super.parseFunctionBody(node, allowExpression, isMethod);\n      node.expression = node.body.type !== \"BlockStatement\";\n    }\n\n    // @ts-expect-error plugin may override interfaces\n    parseMethod<\n      T extends N.ClassPrivateMethod | N.ObjectMethod | N.ClassMethod,\n    >(\n      node: Undone<T>,\n      isGenerator: boolean,\n      isAsync: boolean,\n      isConstructor: boolean,\n      allowDirectSuper: boolean,\n      type: T[\"type\"],\n      inClassScope: boolean = false,\n    ): N.EstreeMethodDefinition {\n      let funcNode = this.startNode<N.MethodLike>();\n      funcNode.kind = node.kind; // provide kind, so super method correctly sets state\n      funcNode = super.parseMethod(\n        // @ts-expect-error todo(flow->ts)\n        funcNode,\n        isGenerator,\n        isAsync,\n        isConstructor,\n        allowDirectSuper,\n        type,\n        inClassScope,\n      );\n      // @ts-expect-error mutate AST types\n      funcNode.type = \"FunctionExpression\";\n      delete funcNode.kind;\n      // @ts-expect-error mutate AST types\n      node.value = funcNode;\n      if (type === \"ClassPrivateMethod\") {\n        node.computed = false;\n      }\n      return this.finishNode(\n        // @ts-expect-error cast methods to estree types\n        node as Undone<N.EstreeMethodDefinition>,\n        \"MethodDefinition\",\n      );\n    }\n\n    parseClassProperty(...args: [N.ClassProperty]): any {\n      const propertyNode = super.parseClassProperty(...args) as any;\n      if (!process.env.BABEL_8_BREAKING) {\n        if (!this.getPluginOption(\"estree\", \"classFeatures\")) {\n          return propertyNode as N.EstreePropertyDefinition;\n        }\n      }\n      propertyNode.type = \"PropertyDefinition\";\n      return propertyNode as N.EstreePropertyDefinition;\n    }\n\n    parseClassPrivateProperty(...args: [N.ClassPrivateProperty]): any {\n      const propertyNode = super.parseClassPrivateProperty(...args) as any;\n      if (!process.env.BABEL_8_BREAKING) {\n        if (!this.getPluginOption(\"estree\", \"classFeatures\")) {\n          return propertyNode as N.EstreePropertyDefinition;\n        }\n      }\n      propertyNode.type = \"PropertyDefinition\";\n      propertyNode.computed = false;\n      return propertyNode as 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 | undefined | null {\n      const node: N.EstreeProperty = super.parseObjectMethod(\n        prop,\n        isGenerator,\n        isAsync,\n        isPattern,\n        isAccessor,\n      ) as any;\n\n      if (node) {\n        node.type = \"Property\";\n        if ((node as any as N.ClassMethod).kind === \"method\") {\n          node.kind = \"init\";\n        }\n        node.shorthand = false;\n      }\n\n      return node as any;\n    }\n\n    parseObjectProperty(\n      prop: N.ObjectProperty,\n      startLoc: Position | undefined | null,\n      isPattern: boolean,\n      refExpressionErrors?: ExpressionErrors | null,\n    ): N.ObjectProperty | undefined | null {\n      const node: N.EstreeProperty = super.parseObjectProperty(\n        prop,\n        startLoc,\n        isPattern,\n        refExpressionErrors,\n      ) as any;\n\n      if (node) {\n        node.kind = \"init\";\n        node.type = \"Property\";\n      }\n\n      return node as any;\n    }\n\n    isValidLVal(\n      type: string,\n      isUnparenthesizedInAssign: boolean,\n      binding: BindingTypes,\n    ) {\n      return type === \"Property\"\n        ? \"value\"\n        : super.isValidLVal(type, isUnparenthesizedInAssign, binding);\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): void {\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      } else {\n        super.toAssignable(node, isLHS);\n      }\n    }\n\n    toAssignableObjectExpressionProp(\n      prop: N.Node,\n      isLast: boolean,\n      isLHS: boolean,\n    ) {\n      if (prop.kind === \"get\" || prop.kind === \"set\") {\n        this.raise(Errors.PatternHasAccessor, { at: prop.key });\n      } else if (prop.method) {\n        this.raise(Errors.PatternHasMethod, { at: prop.key });\n      } else {\n        super.toAssignableObjectExpressionProp(prop, isLast, isLHS);\n      }\n    }\n\n    finishCallExpression<T extends N.CallExpression | N.OptionalCallExpression>(\n      unfinished: Undone<T>,\n      optional: boolean,\n    ): T {\n      const node = super.finishCallExpression(unfinished, optional);\n\n      if (node.callee.type === \"Import\") {\n        (node as N.Node as N.EstreeImportExpression).type = \"ImportExpression\";\n        (node as N.Node as N.EstreeImportExpression).source = node.arguments[0];\n        if (\n          this.hasPlugin(\"importAttributes\") ||\n          this.hasPlugin(\"importAssertions\")\n        ) {\n          (node as N.Node as N.EstreeImportExpression).attributes =\n            node.arguments[1] ?? null;\n        }\n        // arguments isn't optional in the type definition\n        delete node.arguments;\n        // 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(\n      unfinished: Undone<N.AnyExport>,\n      decorators: N.Decorator[] | null,\n    ) {\n      const exportStartLoc = this.state.lastTokStartLoc;\n      const node = super.parseExport(unfinished, decorators);\n\n      switch (node.type) {\n        case \"ExportAllDeclaration\":\n          // @ts-expect-error mutating AST types\n          node.exported = null;\n          break;\n\n        case \"ExportNamedDeclaration\":\n          if (\n            node.specifiers.length === 1 &&\n            // @ts-expect-error mutating AST types\n            node.specifiers[0].type === \"ExportNamespaceSpecifier\"\n          ) {\n            // @ts-expect-error mutating AST types\n            node.type = \"ExportAllDeclaration\";\n            // @ts-expect-error mutating AST types\n            node.exported = node.specifiers[0].exported;\n            delete node.specifiers;\n          }\n\n        // fallthrough\n        case \"ExportDefaultDeclaration\":\n          {\n            const { declaration } = node;\n            if (\n              declaration?.type === \"ClassDeclaration\" &&\n              declaration.decorators?.length > 0 &&\n              // decorator comes before export\n              declaration.start === node.start\n            ) {\n              this.resetStartLocation(\n                node,\n                // For compatibility with ESLint's keyword-spacing rule, which assumes that an\n                // export declaration must start with export.\n                // https://github.com/babel/babel/issues/15085\n                // Here we reset export declaration's start to be the start of the export token\n                exportStartLoc,\n              );\n            }\n          }\n\n          break;\n      }\n\n      return node;\n    }\n\n    parseSubscript(\n      base: N.Expression,\n      startLoc: Position,\n      noCalls: boolean | undefined | null,\n      state: N.ParseSubscriptState,\n    ) {\n      const node = super.parseSubscript(base, startLoc, noCalls, state);\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    // @ts-expect-error override interfaces\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<T extends NodeType>(\n      node: Undone<T>,\n      type: T[\"type\"],\n      endLoc: Position,\n    ): T {\n      return toESTreeLocation(super.finishNodeAt(node, type, endLoc));\n    }\n\n    resetStartLocation(node: N.Node, startLoc: Position) {\n      super.resetStartLocation(node, startLoc);\n      toESTreeLocation(node);\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","// 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(\"<tag\"), // JSX opening tag\n  j_cTag: new TokContext(\"</tag\"), // JSX closing tag\n  j_expr: new TokContext(\"<tag>...</tag>\", true), // JSX expressions\n};\n\nif (!process.env.BABEL_8_BREAKING) {\n  types.template = new TokContext(\"`\", true);\n}\n\nexport { types };\n","import { 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 (<name>); 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 | null;\n};\n\n// Internally the tokenizer stores token as a number\nexport 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 | undefined | null;\n  beforeExpr: boolean;\n  startsExpr: boolean;\n  rightAssociative: boolean;\n  isLoop: boolean;\n  isAssign: boolean;\n  prefix: boolean;\n  postfix: boolean;\n  binop: number | undefined | null;\n  // todo(Babel 8): remove updateContext from exposed token layout\n  declare updateContext:\n    | ((context: Array<TokContext>) => void)\n    | undefined\n    | null;\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<string, TokenType>();\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 type InternalTokenTypes = typeof tt;\n\nexport const tt = {\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(\"}\"),\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  _using: createKeywordLike(\"using\", { 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  _satisfies: createKeywordLike(\"satisfies\", { 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} as const;\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 tokenIsBinaryOperator(token: TokenType): boolean {\n  return tokenBinops[token] !== -1;\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","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\\u0cf3\\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-\\u0ece\\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,20,1,64,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,16,0,2,12,2,33,125,0,80,921,103,110,18,195,2637,96,16,1071,18,5,4026,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,16,0,30,2,3,0,15,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,7,5,262,61,147,44,11,6,17,0,322,29,19,43,485,27,757,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,4153,7,221,3,5761,15,7472,3104,541,1507,4938,6,4191];\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,81,2,71,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,3,0,158,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,10,1,2,0,49,6,4,4,14,9,5351,0,7,14,13835,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,101,0,161,6,10,9,357,0,62,13,499,13,983,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\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","// 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_STATIC_BLOCK | 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            = 0b0000000_0000_01,\n             BIND_KIND_TYPE             = 0b0000000_0000_10,\n             // Used in checkLVal and declareName to determine the type of a binding\n             BIND_SCOPE_VAR             = 0b0000000_0001_00, // Var-style binding\n             BIND_SCOPE_LEXICAL         = 0b0000000_0010_00, // Let- or const-style binding\n             BIND_SCOPE_FUNCTION        = 0b0000000_0100_00, // Function declaration\n             BIND_SCOPE_OUTSIDE         = 0b0000000_1000_00, // Special case for function names as\n                                                   // bound inside the function\n             // Misc flags\n             BIND_FLAGS_NONE            = 0b00000001_0000_00,\n             BIND_FLAGS_CLASS           = 0b00000010_0000_00,\n             BIND_FLAGS_TS_ENUM         = 0b00000100_0000_00,\n             BIND_FLAGS_TS_CONST_ENUM   = 0b00001000_0000_00,\n             BIND_FLAGS_TS_EXPORT_ONLY  = 0b00010000_0000_00,\n             BIND_FLAGS_FLOW_DECLARE_FN = 0b00100000_0000_00,\n             BIND_FLAGS_TS_IMPORT       = 0b01000000_0000_00,\n             // Whether \"let\" should be allowed in bound names in sloppy mode\n             BIND_FLAGS_NO_LET_IN_LEXICAL = 0b10000000_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|BIND_FLAGS_NO_LET_IN_LEXICAL,\n             BIND_LEXICAL       = BIND_KIND_VALUE | 0              | BIND_SCOPE_LEXICAL  | BIND_FLAGS_NO_LET_IN_LEXICAL,\n             BIND_CATCH_PARAM   = 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|BIND_FLAGS_NO_LET_IN_LEXICAL,\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             BIND_TS_TYPE_IMPORT= 0               | BIND_KIND_TYPE | 0                   | BIND_FLAGS_TS_IMPORT     ,\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","import {\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 type { Position } from \"./location\";\nimport type * as N from \"../types\";\nimport { Errors } from \"../parse-error\";\nimport type Tokenizer from \"../tokenizer\";\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<string> = new Set();\n  // A set of lexically-declared names in the current lexical scope\n  lexical: Set<string> = new Set();\n  // A set of lexically-declared FunctionDeclaration names in the current lexical scope\n  functions: Set<string> = 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<IScope extends Scope = Scope> {\n  parser: Tokenizer;\n  scopeStack: Array<IScope> = [];\n  inModule: boolean;\n  undefinedExports: Map<string, Position> = new Map();\n\n  constructor(parser: Tokenizer, inModule: boolean) {\n    this.parser = parser;\n    this.inModule = inModule;\n  }\n\n  get inTopLevel() {\n    return (this.currentScope().flags & SCOPE_PROGRAM) > 0;\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\n  enter(flags: ScopeFlags) {\n    /*:: +createScope: (flags: ScopeFlags) => IScope; */\n    // @ts-expect-error This method will be overwritten by subclasses\n    this.scopeStack.push(this.createScope(flags));\n  }\n\n  exit(): ScopeFlags {\n    const scope = this.scopeStack.pop();\n    return scope.flags;\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 | SCOPE_STATIC_BLOCK) ||\n      (!this.parser.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.parser.inModule && scope.flags & SCOPE_PROGRAM) {\n      this.undefinedExports.delete(name);\n    }\n  }\n\n  maybeExportDefined(scope: IScope, name: string) {\n    if (this.parser.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.parser.raise(Errors.VarRedeclaration, {\n        at: loc,\n        identifierName: name,\n      });\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        // Annex B.3.4\n        // https://tc39.es/ecma262/#sec-variablestatements-in-catch-blocks\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  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  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","import type { 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 type * 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<string> = new Set();\n}\n\nexport default class FlowScopeHandler extends ScopeHandler<FlowScope> {\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(name, bindingType, loc);\n  }\n\n  isRedeclaredInScope(\n    scope: FlowScope,\n    name: string,\n    bindingType: BindingTypes,\n  ): boolean {\n    if (super.isRedeclaredInScope(scope, name, bindingType)) 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","import 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\";\nimport type {\n  ParserPluginWithOptions,\n  PluginConfig,\n  PluginOptions,\n} from \"../typings\";\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<any>;\n  declare classScope: ClassScopeHandler;\n  declare prodParam: ProductionParameterHandler;\n  declare expressionScope: ExpressionScopeHandler;\n  declare plugins: PluginsMap;\n  declare filename: string | undefined | null;\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<string>;\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(\n        pluginOptions,\n      ) as (keyof typeof pluginOptions)[]) {\n        if (actualOptions?.[key] !== pluginOptions[key]) {\n          return false;\n        }\n      }\n      return true;\n    }\n  }\n\n  getPluginOption<\n    PluginName extends ParserPluginWithOptions[0],\n    OptionName extends keyof PluginOptions<PluginName>,\n  >(plugin: PluginName, name: OptionName) {\n    return (this.plugins.get(plugin) as null | PluginOptions<PluginName>)?.[\n      name\n    ];\n  }\n}\n","/*:: declare var invariant; */\n\nimport BaseParser from \"./base\";\nimport type { Comment, Node, Identifier } from \"../types\";\nimport * as charCodes from \"charcodes\";\nimport type { Undone } from \"./node\";\n\n/**\n * A whitespace token containing comments\n */\nexport type CommentWhitespace = {\n  /**\n   * the start of the whitespace token.\n   */\n  start: number;\n  /**\n   * the end of the whitespace token.\n   */\n  end: number;\n  /**\n   * the containing comments\n   */\n  comments: Array<Comment>;\n  /**\n   * the immediately preceding AST node of the whitespace token\n   */\n  leadingNode: Node | null;\n  /**\n   * the immediately following AST node of the whitespace token\n   */\n  trailingNode: Node | null;\n  /**\n   * the innermost AST node containing the whitespace with minimal size (|end - start|)\n   */\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 */\nfunction setTrailingComments(node: Undone<Node>, comments: Array<Comment>) {\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 */\nfunction setLeadingComments(node: Undone<Node>, comments: Array<Comment>) {\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 */\nexport function setInnerComments(\n  node: Undone<Node>,\n  comments?: Array<Comment>,\n) {\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 */\nfunction adjustInnerComments(\n  node: Undone<Node>,\n  elements: Array<Node>,\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\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  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  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 remaining 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  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  /* eslint-disable no-irregular-whitespace */\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 reinterpret 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   * ```\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 node the last finished AST node _before_ current token\n   */\n  /* eslint-enable no-irregular-whitespace */\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  /* eslint-disable no-irregular-whitespace */\n  /**\n   * Reset previous node leading comments, assuming that `node` is a\n   * single-token node. Used in import phase modifiers parsing. We parse\n   * `module` in `import module foo from ...` as an identifier but may\n   * reinterpret it into a phase modifier later. In this case the identifier is\n   * not part of the AST and we should sync the knowledge to commentStacks\n   *\n   * For example, when parsing\n   * ```\n   * import /* 1 */ module a from \"a\";\n   * ```\n   * the comment whitespace `/* 1 */` has trailing node Identifier(module). When\n   * we see that `module` is not a default import binding, we mark `/* 1 */` as\n   * inner comments of the ImportDeclaration. So `/* 1 */` should be detached from\n   * the Identifier node.\n   *\n   * @param node the last finished AST node _before_ current token\n   */\n  /* eslint-enable no-irregular-whitespace */\n  resetPreviousIdentifierLeadingComments(node: Identifier) {\n    const { commentStack } = this.state;\n    const { length } = commentStack;\n    if (length === 0) return;\n\n    if (commentStack[length - 1].trailingNode === node) {\n      commentStack[length - 1].trailingNode = null;\n    } else if (length >= 2 && commentStack[length - 2].trailingNode === node) {\n      commentStack[length - 2].trailingNode = 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  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","import * 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]|\\/\\/.*|\\/\\*.*?\\*\\/)*/g;\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","import type { Options } from \"../options\";\nimport type * 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 { Errors } from \"../parse-error\";\nimport type { ParseError } from \"../parse-error\";\n\nexport type DeferredStrictError =\n  | typeof Errors.StrictNumericEscape\n  | typeof Errors.StrictOctalLiteral;\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  // 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: ParseError<any>[] = [];\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  inDisallowConditionalTypesContext: 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\" | undefined | null;\n    name?: string | null;\n    statementStart?: number;\n  }> = [];\n\n  // Comment store for Program.comments\n  comments: Array<N.Comment> = [];\n\n  // Comment attachment store\n  commentStack: Array<CommentWhitespace> = [];\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  // this is initialized when generating the second token.\n  lastTokEndLoc: Position = null;\n  // 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<TokContext> = [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  // Used to track invalid escape sequences in template literals,\n  // that must be reported if the template is not tagged.\n  firstInvalidTemplateEscapePos: null | Position = null;\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<number, [DeferredStrictError, Position]> = 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) as (keyof State)[];\n    for (let i = 0, length = keys.length; i < length; i++) {\n      const key = keys[i];\n      let val = this[key];\n\n      if (!skipArrays && Array.isArray(val)) {\n        val = val.slice();\n      }\n\n      // @ts-expect-error val must conform to S[key]\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  context: TokContext[];\n  startLoc: Position;\n  lastTokEndLoc: Position;\n  curLine: number;\n  lineStart: number;\n  curPosition: () => Position;\n  /* Used only in readToken_mult_modulo */\n  inType: boolean;\n  // These boolean properties are not initialized in createLookaheadState()\n  // instead they will only be set by the tokenizer\n  containsEsc?: boolean;\n};\n","import * as charCodes from \"charcodes\";\n\n// The following character codes are forbidden from being\n// an immediate sibling of NumericLiteralSeparator _\nconst forbiddenNumericSeparatorSiblings = {\n  decBinOct: new Set<number>([\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: new Set<number>([\n    charCodes.dot,\n    charCodes.uppercaseX,\n    charCodes.underscore, // multiple separators are not allowed\n    charCodes.lowercaseX,\n  ]),\n};\n\nconst isAllowedNumericSeparatorSibling = {\n  // 0 - 1\n  bin: (ch: number) => ch === charCodes.digit0 || ch === charCodes.digit1,\n\n  // 0 - 7\n  oct: (ch: number) => ch >= charCodes.digit0 && ch <= charCodes.digit7,\n\n  // 0 - 9\n  dec: (ch: number) => ch >= charCodes.digit0 && ch <= charCodes.digit9,\n\n  // 0 - 9, A - F, a - f,\n  hex: (ch: number) =>\n    (ch >= charCodes.digit0 && ch <= charCodes.digit9) ||\n    (ch >= charCodes.uppercaseA && ch <= charCodes.uppercaseF) ||\n    (ch >= charCodes.lowercaseA && ch <= charCodes.lowercaseF),\n};\n\nexport type StringContentsErrorHandlers = EscapedCharErrorHandlers & {\n  unterminated(\n    initialPos: number,\n    initialLineStart: number,\n    initialCurLine: number,\n  ): void;\n};\n\nexport function readStringContents(\n  type: \"single\" | \"double\" | \"template\",\n  input: string,\n  pos: number,\n  lineStart: number,\n  curLine: number,\n  errors: StringContentsErrorHandlers,\n) {\n  const initialPos = pos;\n  const initialLineStart = lineStart;\n  const initialCurLine = curLine;\n\n  let out = \"\";\n  let firstInvalidLoc = null;\n  let chunkStart = pos;\n  const { length } = input;\n  for (;;) {\n    if (pos >= length) {\n      errors.unterminated(initialPos, initialLineStart, initialCurLine);\n      out += input.slice(chunkStart, pos);\n      break;\n    }\n    const ch = input.charCodeAt(pos);\n    if (isStringEnd(type, ch, input, pos)) {\n      out += input.slice(chunkStart, pos);\n      break;\n    }\n    if (ch === charCodes.backslash) {\n      out += input.slice(chunkStart, pos);\n      const res = readEscapedChar(\n        input,\n        pos,\n        lineStart,\n        curLine,\n        type === \"template\",\n        errors,\n      );\n      if (res.ch === null && !firstInvalidLoc) {\n        firstInvalidLoc = { pos, lineStart, curLine };\n      } else {\n        out += res.ch;\n      }\n      ({ pos, lineStart, curLine } = res);\n      chunkStart = pos;\n    } else if (\n      ch === charCodes.lineSeparator ||\n      ch === charCodes.paragraphSeparator\n    ) {\n      ++pos;\n      ++curLine;\n      lineStart = pos;\n    } else if (ch === charCodes.lineFeed || ch === charCodes.carriageReturn) {\n      if (type === \"template\") {\n        out += input.slice(chunkStart, pos) + \"\\n\";\n        ++pos;\n        if (\n          ch === charCodes.carriageReturn &&\n          input.charCodeAt(pos) === charCodes.lineFeed\n        ) {\n          ++pos;\n        }\n        ++curLine;\n        chunkStart = lineStart = pos;\n      } else {\n        errors.unterminated(initialPos, initialLineStart, initialCurLine);\n      }\n    } else {\n      ++pos;\n    }\n  }\n  return process.env.BABEL_8_BREAKING\n    ? { pos, str: out, firstInvalidLoc, lineStart, curLine }\n    : {\n        pos,\n        str: out,\n        firstInvalidLoc,\n        lineStart,\n        curLine,\n        containsInvalid: !!firstInvalidLoc,\n      };\n}\n\nfunction isStringEnd(\n  type: \"single\" | \"double\" | \"template\",\n  ch: number,\n  input: string,\n  pos: number,\n) {\n  if (type === \"template\") {\n    return (\n      ch === charCodes.graveAccent ||\n      (ch === charCodes.dollarSign &&\n        input.charCodeAt(pos + 1) === charCodes.leftCurlyBrace)\n    );\n  }\n  return (\n    ch === (type === \"double\" ? charCodes.quotationMark : charCodes.apostrophe)\n  );\n}\n\ntype EscapedCharErrorHandlers = HexCharErrorHandlers &\n  CodePointErrorHandlers & {\n    strictNumericEscape(pos: number, lineStart: number, curLine: number): void;\n  };\n\nfunction readEscapedChar(\n  input: string,\n  pos: number,\n  lineStart: number,\n  curLine: number,\n  inTemplate: boolean,\n  errors: EscapedCharErrorHandlers,\n) {\n  const throwOnInvalid = !inTemplate;\n  pos++; // skip '\\'\n\n  const res = (ch: string | null) => ({ pos, ch, lineStart, curLine });\n\n  const ch = input.charCodeAt(pos++);\n  switch (ch) {\n    case charCodes.lowercaseN:\n      return res(\"\\n\");\n    case charCodes.lowercaseR:\n      return res(\"\\r\");\n    case charCodes.lowercaseX: {\n      let code;\n      ({ code, pos } = readHexChar(\n        input,\n        pos,\n        lineStart,\n        curLine,\n        2,\n        false,\n        throwOnInvalid,\n        errors,\n      ));\n      return res(code === null ? null : String.fromCharCode(code));\n    }\n    case charCodes.lowercaseU: {\n      let code;\n      ({ code, pos } = readCodePoint(\n        input,\n        pos,\n        lineStart,\n        curLine,\n        throwOnInvalid,\n        errors,\n      ));\n      return res(code === null ? null : String.fromCodePoint(code));\n    }\n    case charCodes.lowercaseT:\n      return res(\"\\t\");\n    case charCodes.lowercaseB:\n      return res(\"\\b\");\n    case charCodes.lowercaseV:\n      return res(\"\\u000b\");\n    case charCodes.lowercaseF:\n      return res(\"\\f\");\n    case charCodes.carriageReturn:\n      if (input.charCodeAt(pos) === charCodes.lineFeed) {\n        ++pos;\n      }\n    // fall through\n    case charCodes.lineFeed:\n      lineStart = pos;\n      ++curLine;\n    // fall through\n    case charCodes.lineSeparator:\n    case charCodes.paragraphSeparator:\n      return res(\"\");\n    case charCodes.digit8:\n    case charCodes.digit9:\n      if (inTemplate) {\n        return res(null);\n      } else {\n        errors.strictNumericEscape(pos - 1, lineStart, curLine);\n      }\n    // fall through\n    default:\n      if (ch >= charCodes.digit0 && ch <= charCodes.digit7) {\n        const startPos = pos - 1;\n        const match = input.slice(startPos, pos + 2).match(/^[0-7]+/)!;\n\n        let octalStr = match[0];\n\n        let octal = parseInt(octalStr, 8);\n        if (octal > 255) {\n          octalStr = octalStr.slice(0, -1);\n          octal = parseInt(octalStr, 8);\n        }\n        pos += octalStr.length - 1;\n        const next = input.charCodeAt(pos);\n        if (\n          octalStr !== \"0\" ||\n          next === charCodes.digit8 ||\n          next === charCodes.digit9\n        ) {\n          if (inTemplate) {\n            return res(null);\n          } else {\n            errors.strictNumericEscape(startPos, lineStart, curLine);\n          }\n        }\n\n        return res(String.fromCharCode(octal));\n      }\n\n      return res(String.fromCharCode(ch));\n  }\n}\n\ntype HexCharErrorHandlers = IntErrorHandlers & {\n  invalidEscapeSequence(pos: number, lineStart: number, curLine: number): void;\n};\n\n// Used to read character escape sequences ('\\x', '\\u').\nfunction readHexChar(\n  input: string,\n  pos: number,\n  lineStart: number,\n  curLine: number,\n  len: number,\n  forceLen: boolean,\n  throwOnInvalid: boolean,\n  errors: HexCharErrorHandlers,\n) {\n  const initialPos = pos;\n  let n;\n  ({ n, pos } = readInt(\n    input,\n    pos,\n    lineStart,\n    curLine,\n    16,\n    len,\n    forceLen,\n    false,\n    errors,\n    /* bailOnError */ !throwOnInvalid,\n  ));\n  if (n === null) {\n    if (throwOnInvalid) {\n      errors.invalidEscapeSequence(initialPos, lineStart, curLine);\n    } else {\n      pos = initialPos - 1;\n    }\n  }\n  return { code: n, pos };\n}\n\nexport type IntErrorHandlers = {\n  numericSeparatorInEscapeSequence(\n    pos: number,\n    lineStart: number,\n    curLine: number,\n  ): void;\n  unexpectedNumericSeparator(\n    pos: number,\n    lineStart: number,\n    curLine: number,\n  ): void;\n  // It can return \"true\" to indicate that the error was handled\n  // and the int parsing should continue.\n  invalidDigit(\n    pos: number,\n    lineStart: number,\n    curLine: number,\n    radix: number,\n  ): boolean;\n};\n\nexport function readInt(\n  input: string,\n  pos: number,\n  lineStart: number,\n  curLine: number,\n  radix: number,\n  len: number | undefined,\n  forceLen: boolean,\n  allowNumSeparator: boolean | \"bail\",\n  errors: IntErrorHandlers,\n  bailOnError: boolean,\n) {\n  const start = pos;\n  const forbiddenSiblings =\n    radix === 16\n      ? forbiddenNumericSeparatorSiblings.hex\n      : forbiddenNumericSeparatorSiblings.decBinOct;\n  const isAllowedSibling =\n    radix === 16\n      ? isAllowedNumericSeparatorSibling.hex\n      : radix === 10\n      ? isAllowedNumericSeparatorSibling.dec\n      : radix === 8\n      ? isAllowedNumericSeparatorSibling.oct\n      : isAllowedNumericSeparatorSibling.bin;\n\n  let invalid = false;\n  let total = 0;\n\n  for (let i = 0, e = len == null ? Infinity : len; i < e; ++i) {\n    const code = input.charCodeAt(pos);\n    let val;\n\n    if (code === charCodes.underscore && allowNumSeparator !== \"bail\") {\n      const prev = input.charCodeAt(pos - 1);\n      const next = input.charCodeAt(pos + 1);\n\n      if (!allowNumSeparator) {\n        if (bailOnError) return { n: null, pos };\n        errors.numericSeparatorInEscapeSequence(pos, lineStart, curLine);\n      } else if (\n        Number.isNaN(next) ||\n        !isAllowedSibling(next) ||\n        forbiddenSiblings.has(prev) ||\n        forbiddenSiblings.has(next)\n      ) {\n        if (bailOnError) return { n: null, pos };\n        errors.unexpectedNumericSeparator(pos, lineStart, curLine);\n      }\n\n      // Ignore this _ character\n      ++pos;\n      continue;\n    }\n\n    if (code >= charCodes.lowercaseA) {\n      val = code - charCodes.lowercaseA + charCodes.lineFeed;\n    } else if (code >= charCodes.uppercaseA) {\n      val = code - charCodes.uppercaseA + charCodes.lineFeed;\n    } else if (charCodes.isDigit(code)) {\n      val = code - charCodes.digit0; // 0-9\n    } else {\n      val = Infinity;\n    }\n    if (val >= radix) {\n      // If we found a digit which is too big, errors.invalidDigit can return true to avoid\n      // breaking the loop (this is used for error recovery).\n      if (val <= 9 && bailOnError) {\n        return { n: null, pos };\n      } else if (\n        val <= 9 &&\n        errors.invalidDigit(pos, lineStart, curLine, radix)\n      ) {\n        val = 0;\n      } else if (forceLen) {\n        val = 0;\n        invalid = true;\n      } else {\n        break;\n      }\n    }\n    ++pos;\n    total = total * radix + val;\n  }\n  if (pos === start || (len != null && pos - start !== len) || invalid) {\n    return { n: null, pos };\n  }\n\n  return { n: total, pos };\n}\n\nexport type CodePointErrorHandlers = HexCharErrorHandlers & {\n  invalidCodePoint(pos: number, lineStart: number, curLine: number): void;\n};\n\nexport function readCodePoint(\n  input: string,\n  pos: number,\n  lineStart: number,\n  curLine: number,\n  throwOnInvalid: boolean,\n  errors: CodePointErrorHandlers,\n) {\n  const ch = input.charCodeAt(pos);\n  let code;\n\n  if (ch === charCodes.leftCurlyBrace) {\n    ++pos;\n    ({ code, pos } = readHexChar(\n      input,\n      pos,\n      lineStart,\n      curLine,\n      input.indexOf(\"}\", pos) - pos,\n      true,\n      throwOnInvalid,\n      errors,\n    ));\n    ++pos;\n    if (code !== null && code > 0x10ffff) {\n      if (throwOnInvalid) {\n        errors.invalidCodePoint(pos, lineStart, curLine);\n      } else {\n        return { code: null, pos };\n      }\n    }\n  } else {\n    ({ code, pos } = readHexChar(\n      input,\n      pos,\n      lineStart,\n      curLine,\n      4,\n      false,\n      throwOnInvalid,\n      errors,\n    ));\n  }\n  return { code, pos };\n}\n","/*:: declare var invariant; */\n\nimport type { Options } from \"../options\";\nimport {\n  Position,\n  SourceLocation,\n  createPositionWithColumnOffset,\n} from \"../util/location\";\nimport CommentsParser, { type CommentWhitespace } from \"../parser/comments\";\nimport type * 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 {\n  Errors,\n  type ParseError,\n  type ParseErrorConstructor,\n  type RaiseProperties,\n} from \"../parse-error\";\nimport {\n  lineBreakG,\n  isNewLine,\n  isWhitespace,\n  skipWhiteSpace,\n  skipWhiteSpaceInLine,\n} from \"../util/whitespace\";\nimport State from \"./state\";\nimport type { LookaheadState, DeferredStrictError } from \"./state\";\n\nimport {\n  readInt,\n  readCodePoint,\n  readStringContents,\n  type IntErrorHandlers,\n  type CodePointErrorHandlers,\n  type StringContentsErrorHandlers,\n} from \"@babel/helper-string-parser\";\n\nimport type { Plugin } from \"../typings\";\n\nfunction buildPosition(pos: number, lineStart: number, curLine: number) {\n  return new Position(curLine, pos - lineStart, pos);\n}\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  charCodes.lowercaseV,\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 abstract class Tokenizer extends CommentsParser {\n  isLookahead: boolean;\n\n  // Token store.\n  tokens: Array<Token | N.Comment> = [];\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  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  match(type: TokenType): boolean {\n    return this.state.type === type;\n  }\n\n  /**\n   * Create a LookaheadState from current parser state\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  lookahead(): LookaheadState {\n    const old = this.state;\n    // @ts-expect-error For performance we use a simplified tokenizer state structure\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  /**\n   * Similar to nextToken, but it will stop at line break when it is seen before the next token\n   *\n   * @returns {number} position of the next token start or line break, whichever is seen first.\n   * @memberof Tokenizer\n   */\n  nextTokenInLineStart(): number {\n    return this.nextTokenInLineStartSince(this.state.pos);\n  }\n\n  nextTokenInLineStartSince(pos: number): number {\n    skipWhiteSpaceInLine.lastIndex = pos;\n    return skipWhiteSpaceInLine.test(this.input)\n      ? skipWhiteSpaceInLine.lastIndex\n      : pos;\n  }\n\n  /**\n   * Similar to lookaheadCharCode, but it will return the char code of line break if it is\n   * seen before the next token\n   *\n   * @returns {number} char code of the next token start or line break, whichever is seen first.\n   * @memberof Tokenizer\n   */\n  lookaheadInLineCharCode(): number {\n    return this.input.charCodeAt(this.nextTokenInLineStart());\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(([toParseError, at]) =>\n        this.raise(toParseError, { at }),\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 properties.\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  // Skips a block comment, whose end is marked by commentEnd.\n  // *-/ is used by the Flow plugin, when parsing block comments nested\n  // inside Flow comments.\n  skipBlockComment(commentEnd: \"*/\" | \"*-/\"): N.CommentBlock | undefined {\n    let startLoc;\n    if (!this.isLookahead) startLoc = this.state.curPosition();\n    const start = this.state.pos;\n    const end = this.input.indexOf(commentEnd, 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 + commentEnd.length;\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.CommentBlock = {\n      type: \"CommentBlock\",\n      value: this.input.slice(start + 2, end),\n      start,\n      end: end + commentEnd.length,\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 | undefined {\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.CommentLine = {\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 (\n            ch === charCodes.dash &&\n            !this.inModule &&\n            this.options.annexB\n          ) {\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 (\n            ch === charCodes.lessThan &&\n            !this.inModule &&\n            this.options.annexB\n          ) {\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              // `<!--`, an XML-style comment that should be interpreted as a line comment\n              const comment = this.skipLineComment(4);\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 {\n            break loop;\n          }\n      }\n    }\n\n    if (comments.length > 0) {\n      const end = this.state.pos;\n      const commentWhitespace: CommentWhitespace = {\n        start: spaceStart,\n        end,\n        comments,\n        leadingNode: null,\n        trailingNode: null,\n        containingNode: null,\n      };\n      this.state.commentStack.push(commentWhitespace);\n    }\n  }\n\n  // Called at the end of every token. Sets `end`, `val`, and\n  // maintains `context` and `canStartJSXElement`, and skips the space after\n  // the token, so that the next one's `start` will point at the\n  // right position.\n\n  finishToken(type: TokenType, val?: any): void {\n    this.state.end = this.state.pos;\n    this.state.endLoc = this.state.curPosition();\n    const prevType = this.state.type;\n    this.state.type = type;\n    this.state.value = val;\n\n    if (!this.isLookahead) {\n      this.updateContext(prevType);\n    }\n  }\n\n  replaceToken(type: TokenType): void {\n    this.state.type = type;\n    // @ts-expect-error the prevType of updateContext is required\n    // only when the new type is tt.slash/tt.jsxTagEnd\n    this.updateContext();\n  }\n\n  // ### Token reading\n\n  // This is the function that is called to fetch the next token. It\n  // is somewhat obscure, because it works in character codes rather\n  // than characters, and because operator parsing has been inlined\n  // into it.\n  //\n  // All in the name of speed.\n\n  // number sign is \"#\"\n  readToken_numberSign(): void {\n    if (this.state.pos === 0 && this.readToken_interpreter()) {\n      return;\n    }\n\n    const nextPos = this.state.pos + 1;\n    const next = this.codePointAtPos(nextPos);\n    if (next >= charCodes.digit0 && next <= charCodes.digit9) {\n      throw this.raise(Errors.UnexpectedDigitAfterHash, {\n        at: this.state.curPosition(),\n      });\n    }\n\n    if (\n      next === charCodes.leftCurlyBrace ||\n      (next === charCodes.leftSquareBracket && this.hasPlugin(\"recordAndTuple\"))\n    ) {\n      // When we see `#{`, it is likely to be a hash record.\n      // However we don't yell at `#[` since users may intend to use \"computed private fields\",\n      // which is not allowed in the spec. Throwing expecting recordAndTuple is\n      // misleading\n      this.expectPlugin(\"recordAndTuple\");\n      if (this.getPluginOption(\"recordAndTuple\", \"syntaxType\") === \"bar\") {\n        throw this.raise(\n          next === charCodes.leftCurlyBrace\n            ? Errors.RecordExpressionHashIncorrectStartSyntaxType\n            : Errors.TupleExpressionHashIncorrectStartSyntaxType,\n          { at: this.state.curPosition() },\n        );\n      }\n\n      this.state.pos += 2;\n      if (next === charCodes.leftCurlyBrace) {\n        // #{\n        this.finishToken(tt.braceHashL);\n      } else {\n        // #[\n        this.finishToken(tt.bracketHashL);\n      }\n    } else if (isIdentifierStart(next)) {\n      ++this.state.pos;\n      this.finishToken(tt.privateName, this.readWord1(next));\n    } else if (next === charCodes.backslash) {\n      ++this.state.pos;\n      this.finishToken(tt.privateName, this.readWord1());\n    } else {\n      this.finishOp(tt.hash, 1);\n    }\n  }\n\n  readToken_dot(): void {\n    const next = this.input.charCodeAt(this.state.pos + 1);\n    if (next >= charCodes.digit0 && next <= charCodes.digit9) {\n      this.readNumber(true);\n      return;\n    }\n\n    if (\n      next === charCodes.dot &&\n      this.input.charCodeAt(this.state.pos + 2) === charCodes.dot\n    ) {\n      this.state.pos += 3;\n      this.finishToken(tt.ellipsis);\n    } else {\n      ++this.state.pos;\n      this.finishToken(tt.dot);\n    }\n  }\n\n  readToken_slash(): void {\n    const next = this.input.charCodeAt(this.state.pos + 1);\n    if (next === charCodes.equalsTo) {\n      this.finishOp(tt.slashAssign, 2);\n    } else {\n      this.finishOp(tt.slash, 1);\n    }\n  }\n\n  readToken_interpreter(): boolean {\n    if (this.state.pos !== 0 || this.length < 2) return false;\n\n    let ch = this.input.charCodeAt(this.state.pos + 1);\n    if (ch !== charCodes.exclamationMark) return false;\n\n    const start = this.state.pos;\n    this.state.pos += 1;\n\n    while (!isNewLine(ch) && ++this.state.pos < this.length) {\n      ch = this.input.charCodeAt(this.state.pos);\n    }\n\n    const value = this.input.slice(start + 2, this.state.pos);\n\n    this.finishToken(tt.interpreterDirective, value);\n\n    return true;\n  }\n\n  readToken_mult_modulo(code: number): void {\n    // '%' or '*'\n    let type = code === charCodes.asterisk ? tt.star : tt.modulo;\n    let width = 1;\n    let next = this.input.charCodeAt(this.state.pos + 1);\n\n    // Exponentiation operator '**'\n    if (code === charCodes.asterisk && next === charCodes.asterisk) {\n      width++;\n      next = this.input.charCodeAt(this.state.pos + 2);\n      type = tt.exponent;\n    }\n\n    // '%=' or '*='\n    if (next === charCodes.equalsTo && !this.state.inType) {\n      width++;\n      // `tt.moduloAssign` is only needed to support % as a Hack-pipe topic token.\n      // If the proposal ends up choosing a different token,\n      // it can be merged with tt.assign.\n      type = code === charCodes.percentSign ? tt.moduloAssign : tt.assign;\n    }\n\n    this.finishOp(type, width);\n  }\n\n  readToken_pipe_amp(code: number): void {\n    // '||' '&&' '||=' '&&='\n    const next = this.input.charCodeAt(this.state.pos + 1);\n\n    if (next === code) {\n      if (this.input.charCodeAt(this.state.pos + 2) === charCodes.equalsTo) {\n        this.finishOp(tt.assign, 3);\n      } else {\n        this.finishOp(\n          code === charCodes.verticalBar ? tt.logicalOR : tt.logicalAND,\n          2,\n        );\n      }\n      return;\n    }\n\n    if (code === charCodes.verticalBar) {\n      // '|>'\n      if (next === charCodes.greaterThan) {\n        this.finishOp(tt.pipeline, 2);\n        return;\n      }\n      // '|}'\n      if (\n        this.hasPlugin(\"recordAndTuple\") &&\n        next === charCodes.rightCurlyBrace\n      ) {\n        if (this.getPluginOption(\"recordAndTuple\", \"syntaxType\") !== \"bar\") {\n          throw this.raise(Errors.RecordExpressionBarIncorrectEndSyntaxType, {\n            at: this.state.curPosition(),\n          });\n        }\n        this.state.pos += 2;\n        this.finishToken(tt.braceBarR);\n        return;\n      }\n\n      // '|]'\n      if (\n        this.hasPlugin(\"recordAndTuple\") &&\n        next === charCodes.rightSquareBracket\n      ) {\n        if (this.getPluginOption(\"recordAndTuple\", \"syntaxType\") !== \"bar\") {\n          throw this.raise(Errors.TupleExpressionBarIncorrectEndSyntaxType, {\n            at: this.state.curPosition(),\n          });\n        }\n        this.state.pos += 2;\n        this.finishToken(tt.bracketBarR);\n        return;\n      }\n    }\n\n    if (next === charCodes.equalsTo) {\n      this.finishOp(tt.assign, 2);\n      return;\n    }\n\n    this.finishOp(\n      code === charCodes.verticalBar ? tt.bitwiseOR : tt.bitwiseAND,\n      1,\n    );\n  }\n\n  readToken_caret(): void {\n    const next = this.input.charCodeAt(this.state.pos + 1);\n\n    // '^='\n    if (next === charCodes.equalsTo && !this.state.inType) {\n      // `tt.xorAssign` is only needed to support ^ as a Hack-pipe topic token.\n      // If the proposal ends up choosing a different token,\n      // it can be merged with tt.assign.\n      this.finishOp(tt.xorAssign, 2);\n    }\n    // '^^'\n    else if (\n      next === charCodes.caret &&\n      // If the ^^ token is not enabled, we don't throw but parse two single ^s\n      // because it could be a ^ hack token followed by a ^ binary operator.\n      this.hasPlugin([\n        \"pipelineOperator\",\n        { proposal: \"hack\", topicToken: \"^^\" },\n      ])\n    ) {\n      this.finishOp(tt.doubleCaret, 2);\n\n      // `^^^` is forbidden and must be separated by a space.\n      const lookaheadCh = this.input.codePointAt(this.state.pos);\n      if (lookaheadCh === charCodes.caret) {\n        this.unexpected();\n      }\n    }\n    // '^'\n    else {\n      this.finishOp(tt.bitwiseXOR, 1);\n    }\n  }\n\n  readToken_atSign(): void {\n    const next = this.input.charCodeAt(this.state.pos + 1);\n\n    // '@@'\n    if (\n      next === charCodes.atSign &&\n      this.hasPlugin([\n        \"pipelineOperator\",\n        { proposal: \"hack\", topicToken: \"@@\" },\n      ])\n    ) {\n      this.finishOp(tt.doubleAt, 2);\n    }\n    // '@'\n    else {\n      this.finishOp(tt.at, 1);\n    }\n  }\n\n  readToken_plus_min(code: number): void {\n    // '+-'\n    const next = this.input.charCodeAt(this.state.pos + 1);\n\n    if (next === code) {\n      this.finishOp(tt.incDec, 2);\n      return;\n    }\n\n    if (next === charCodes.equalsTo) {\n      this.finishOp(tt.assign, 2);\n    } else {\n      this.finishOp(tt.plusMin, 1);\n    }\n  }\n\n  readToken_lt(): void {\n    // '<'\n    const { pos } = this.state;\n    const next = this.input.charCodeAt(pos + 1);\n\n    if (next === charCodes.lessThan) {\n      if (this.input.charCodeAt(pos + 2) === charCodes.equalsTo) {\n        this.finishOp(tt.assign, 3);\n        return;\n      }\n      this.finishOp(tt.bitShiftL, 2);\n      return;\n    }\n\n    if (next === charCodes.equalsTo) {\n      // <=\n      this.finishOp(tt.relational, 2);\n      return;\n    }\n\n    this.finishOp(tt.lt, 1);\n  }\n\n  readToken_gt(): void {\n    // '>'\n    const { pos } = this.state;\n    const next = this.input.charCodeAt(pos + 1);\n\n    if (next === charCodes.greaterThan) {\n      const size =\n        this.input.charCodeAt(pos + 2) === charCodes.greaterThan ? 3 : 2;\n      if (this.input.charCodeAt(pos + size) === charCodes.equalsTo) {\n        this.finishOp(tt.assign, size + 1);\n        return;\n      }\n      this.finishOp(tt.bitShiftR, size);\n      return;\n    }\n\n    if (next === charCodes.equalsTo) {\n      // <= | >=\n      this.finishOp(tt.relational, 2);\n      return;\n    }\n\n    this.finishOp(tt.gt, 1);\n  }\n\n  readToken_eq_excl(code: number): void {\n    // '=!'\n    const next = this.input.charCodeAt(this.state.pos + 1);\n    if (next === charCodes.equalsTo) {\n      this.finishOp(\n        tt.equality,\n        this.input.charCodeAt(this.state.pos + 2) === charCodes.equalsTo\n          ? 3\n          : 2,\n      );\n      return;\n    }\n    if (code === charCodes.equalsTo && next === charCodes.greaterThan) {\n      // '=>'\n      this.state.pos += 2;\n      this.finishToken(tt.arrow);\n      return;\n    }\n    this.finishOp(code === charCodes.equalsTo ? tt.eq : tt.bang, 1);\n  }\n\n  readToken_question(): void {\n    // '?'\n    const next = this.input.charCodeAt(this.state.pos + 1);\n    const next2 = this.input.charCodeAt(this.state.pos + 2);\n    if (next === charCodes.questionMark) {\n      if (next2 === charCodes.equalsTo) {\n        // '??='\n        this.finishOp(tt.assign, 3);\n      } else {\n        // '??'\n        this.finishOp(tt.nullishCoalescing, 2);\n      }\n    } else if (\n      next === charCodes.dot &&\n      !(next2 >= charCodes.digit0 && next2 <= charCodes.digit9)\n    ) {\n      // '.' not followed by a number\n      this.state.pos += 2;\n      this.finishToken(tt.questionDot);\n    } else {\n      ++this.state.pos;\n      this.finishToken(tt.question);\n    }\n  }\n\n  getTokenFromCode(code: number): void {\n    switch (code) {\n      // The interpretation of a dot depends on whether it is followed\n      // by a digit or another two dots.\n\n      case charCodes.dot:\n        this.readToken_dot();\n        return;\n      // Punctuation tokens.\n      case charCodes.leftParenthesis:\n        ++this.state.pos;\n        this.finishToken(tt.parenL);\n        return;\n      case charCodes.rightParenthesis:\n        ++this.state.pos;\n        this.finishToken(tt.parenR);\n        return;\n      case charCodes.semicolon:\n        ++this.state.pos;\n        this.finishToken(tt.semi);\n        return;\n      case charCodes.comma:\n        ++this.state.pos;\n        this.finishToken(tt.comma);\n        return;\n      case charCodes.leftSquareBracket:\n        if (\n          this.hasPlugin(\"recordAndTuple\") &&\n          this.input.charCodeAt(this.state.pos + 1) === charCodes.verticalBar\n        ) {\n          if (this.getPluginOption(\"recordAndTuple\", \"syntaxType\") !== \"bar\") {\n            throw this.raise(\n              Errors.TupleExpressionBarIncorrectStartSyntaxType,\n              { at: this.state.curPosition() },\n            );\n          }\n\n          // [|\n          this.state.pos += 2;\n          this.finishToken(tt.bracketBarL);\n        } else {\n          ++this.state.pos;\n          this.finishToken(tt.bracketL);\n        }\n        return;\n      case charCodes.rightSquareBracket:\n        ++this.state.pos;\n        this.finishToken(tt.bracketR);\n        return;\n      case charCodes.leftCurlyBrace:\n        if (\n          this.hasPlugin(\"recordAndTuple\") &&\n          this.input.charCodeAt(this.state.pos + 1) === charCodes.verticalBar\n        ) {\n          if (this.getPluginOption(\"recordAndTuple\", \"syntaxType\") !== \"bar\") {\n            throw this.raise(\n              Errors.RecordExpressionBarIncorrectStartSyntaxType,\n              { at: this.state.curPosition() },\n            );\n          }\n\n          // {|\n          this.state.pos += 2;\n          this.finishToken(tt.braceBarL);\n        } else {\n          ++this.state.pos;\n          this.finishToken(tt.braceL);\n        }\n        return;\n      case charCodes.rightCurlyBrace:\n        ++this.state.pos;\n        this.finishToken(tt.braceR);\n        return;\n\n      case charCodes.colon:\n        if (\n          this.hasPlugin(\"functionBind\") &&\n          this.input.charCodeAt(this.state.pos + 1) === charCodes.colon\n        ) {\n          this.finishOp(tt.doubleColon, 2);\n        } else {\n          ++this.state.pos;\n          this.finishToken(tt.colon);\n        }\n        return;\n\n      case charCodes.questionMark:\n        this.readToken_question();\n        return;\n\n      case charCodes.graveAccent:\n        this.readTemplateToken();\n        return;\n\n      case charCodes.digit0: {\n        const next = this.input.charCodeAt(this.state.pos + 1);\n        // '0x', '0X' - hex number\n        if (next === charCodes.lowercaseX || next === charCodes.uppercaseX) {\n          this.readRadixNumber(16);\n          return;\n        }\n        // '0o', '0O' - octal number\n        if (next === charCodes.lowercaseO || next === charCodes.uppercaseO) {\n          this.readRadixNumber(8);\n          return;\n        }\n        // '0b', '0B' - binary number\n        if (next === charCodes.lowercaseB || next === charCodes.uppercaseB) {\n          this.readRadixNumber(2);\n          return;\n        }\n      }\n      // Anything else beginning with a digit is an integer, octal\n      // number, or float. (fall through)\n      case charCodes.digit1:\n      case charCodes.digit2:\n      case charCodes.digit3:\n      case charCodes.digit4:\n      case charCodes.digit5:\n      case charCodes.digit6:\n      case charCodes.digit7:\n      case charCodes.digit8:\n      case charCodes.digit9:\n        this.readNumber(false);\n        return;\n\n      // Quotes produce strings.\n      case charCodes.quotationMark:\n      case charCodes.apostrophe:\n        this.readString(code);\n        return;\n\n      // Operators are parsed inline in tiny state machines. '=' (charCodes.equalsTo) is\n      // often referred to. `finishOp` simply skips the amount of\n      // characters it is given as second argument, and returns a token\n      // of the type given by its first argument.\n\n      case charCodes.slash:\n        this.readToken_slash();\n        return;\n\n      case charCodes.percentSign:\n      case charCodes.asterisk:\n        this.readToken_mult_modulo(code);\n        return;\n\n      case charCodes.verticalBar:\n      case charCodes.ampersand:\n        this.readToken_pipe_amp(code);\n        return;\n\n      case charCodes.caret:\n        this.readToken_caret();\n        return;\n\n      case charCodes.plusSign:\n      case charCodes.dash:\n        this.readToken_plus_min(code);\n        return;\n\n      case charCodes.lessThan:\n        this.readToken_lt();\n        return;\n\n      case charCodes.greaterThan:\n        this.readToken_gt();\n        return;\n\n      case charCodes.equalsTo:\n      case charCodes.exclamationMark:\n        this.readToken_eq_excl(code);\n        return;\n\n      case charCodes.tilde:\n        this.finishOp(tt.tilde, 1);\n        return;\n\n      case charCodes.atSign:\n        this.readToken_atSign();\n        return;\n\n      case charCodes.numberSign:\n        this.readToken_numberSign();\n        return;\n\n      case charCodes.backslash:\n        this.readWord();\n        return;\n\n      default:\n        if (isIdentifierStart(code)) {\n          this.readWord(code);\n          return;\n        }\n    }\n\n    throw this.raise(Errors.InvalidOrUnexpectedToken, {\n      at: this.state.curPosition(),\n      unexpected: String.fromCodePoint(code),\n    });\n  }\n\n  finishOp(type: TokenType, size: number): void {\n    const str = this.input.slice(this.state.pos, this.state.pos + size);\n    this.state.pos += size;\n    this.finishToken(type, str);\n  }\n\n  readRegexp(): void {\n    const startLoc = this.state.startLoc;\n    const start = this.state.start + 1;\n    let escaped, inClass;\n    let { pos } = this.state;\n    for (; ; ++pos) {\n      if (pos >= this.length) {\n        // FIXME: explain\n        throw this.raise(Errors.UnterminatedRegExp, {\n          at: createPositionWithColumnOffset(startLoc, 1),\n        });\n      }\n      const ch = this.input.charCodeAt(pos);\n      if (isNewLine(ch)) {\n        throw this.raise(Errors.UnterminatedRegExp, {\n          at: createPositionWithColumnOffset(startLoc, 1),\n        });\n      }\n      if (escaped) {\n        escaped = false;\n      } else {\n        if (ch === charCodes.leftSquareBracket) {\n          inClass = true;\n        } else if (ch === charCodes.rightSquareBracket && inClass) {\n          inClass = false;\n        } else if (ch === charCodes.slash && !inClass) {\n          break;\n        }\n        escaped = ch === charCodes.backslash;\n      }\n    }\n    const content = this.input.slice(start, pos);\n    ++pos;\n\n    let mods = \"\";\n\n    const nextPos = () =>\n      // (pos + 1) + 1 - start\n      createPositionWithColumnOffset(startLoc, pos + 2 - start);\n\n    while (pos < this.length) {\n      const cp = this.codePointAtPos(pos);\n      // It doesn't matter if cp > 0xffff, the loop will either throw or break because we check on cp\n      const char = String.fromCharCode(cp);\n\n      // @ts-expect-error VALID_REGEX_FLAGS.has should accept expanded type: number\n      if (VALID_REGEX_FLAGS.has(cp)) {\n        if (cp === charCodes.lowercaseV) {\n          if (mods.includes(\"u\")) {\n            this.raise(Errors.IncompatibleRegExpUVFlags, { at: nextPos() });\n          }\n        } else if (cp === charCodes.lowercaseU) {\n          if (mods.includes(\"v\")) {\n            this.raise(Errors.IncompatibleRegExpUVFlags, { at: nextPos() });\n          }\n        }\n        if (mods.includes(char)) {\n          this.raise(Errors.DuplicateRegExpFlags, { at: nextPos() });\n        }\n      } else if (isIdentifierChar(cp) || cp === charCodes.backslash) {\n        this.raise(Errors.MalformedRegExpFlags, { at: nextPos() });\n      } else {\n        break;\n      }\n\n      ++pos;\n      mods += char;\n    }\n    this.state.pos = pos;\n\n    this.finishToken(tt.regexp, {\n      pattern: content,\n      flags: mods,\n    });\n  }\n\n  // Read an integer in the given radix. Return null if zero digits\n  // were read, the integer value otherwise. When `len` is given, this\n  // will return `null` unless the integer has exactly `len` digits.\n  // When `forceLen` is `true`, it means that we already know that in case\n  // of a malformed number we have to skip `len` characters anyway, instead\n  // of bailing out early. For example, in \"\\u{123Z}\" we want to read up to }\n  // anyway, while in \"\\u00Z\" we will stop at Z instead of consuming four\n  // characters (and thus the closing quote).\n\n  readInt(\n    radix: number,\n    len?: number,\n    forceLen: boolean = false,\n    allowNumSeparator: boolean | \"bail\" = true,\n  ): number | null {\n    const { n, pos } = readInt(\n      this.input,\n      this.state.pos,\n      this.state.lineStart,\n      this.state.curLine,\n      radix,\n      len,\n      forceLen,\n      allowNumSeparator,\n      this.errorHandlers_readInt,\n      /* bailOnError */ false,\n    );\n    this.state.pos = pos;\n    return n;\n  }\n\n  readRadixNumber(radix: number): void {\n    const startLoc = this.state.curPosition();\n    let isBigInt = false;\n\n    this.state.pos += 2; // 0x\n    const val = this.readInt(radix);\n    if (val == null) {\n      this.raise(Errors.InvalidDigit, {\n        // Numeric literals can't have newlines, so this is safe to do.\n        at: createPositionWithColumnOffset(startLoc, 2),\n        radix,\n      });\n    }\n    const next = this.input.charCodeAt(this.state.pos);\n\n    if (next === charCodes.lowercaseN) {\n      ++this.state.pos;\n      isBigInt = true;\n    } else if (next === charCodes.lowercaseM) {\n      throw this.raise(Errors.InvalidDecimal, { at: startLoc });\n    }\n\n    if (isIdentifierStart(this.codePointAtPos(this.state.pos))) {\n      throw this.raise(Errors.NumberIdentifier, {\n        at: this.state.curPosition(),\n      });\n    }\n\n    if (isBigInt) {\n      const str = this.input\n        .slice(startLoc.index, this.state.pos)\n        .replace(/[_n]/g, \"\");\n      this.finishToken(tt.bigint, str);\n      return;\n    }\n\n    this.finishToken(tt.num, val);\n  }\n\n  // Read an integer, octal integer, or floating-point number.\n\n  readNumber(startsWithDot: boolean): void {\n    const start = this.state.pos;\n    const startLoc = this.state.curPosition();\n    let isFloat = false;\n    let isBigInt = false;\n    let isDecimal = false;\n    let hasExponent = false;\n    let isOctal = false;\n\n    if (!startsWithDot && this.readInt(10) === null) {\n      this.raise(Errors.InvalidNumber, { at: this.state.curPosition() });\n    }\n    const hasLeadingZero =\n      this.state.pos - start >= 2 &&\n      this.input.charCodeAt(start) === charCodes.digit0;\n\n    if (hasLeadingZero) {\n      const integer = this.input.slice(start, this.state.pos);\n      this.recordStrictModeErrors(Errors.StrictOctalLiteral, { at: startLoc });\n      if (!this.state.strict) {\n        // disallow numeric separators in non octal decimals and legacy octal likes\n        const underscorePos = integer.indexOf(\"_\");\n        if (underscorePos > 0) {\n          // Numeric literals can't have newlines, so this is safe to do.\n          this.raise(Errors.ZeroDigitNumericSeparator, {\n            at: createPositionWithColumnOffset(startLoc, underscorePos),\n          });\n        }\n      }\n      isOctal = hasLeadingZero && !/[89]/.test(integer);\n    }\n\n    let next = this.input.charCodeAt(this.state.pos);\n    if (next === charCodes.dot && !isOctal) {\n      ++this.state.pos;\n      this.readInt(10);\n      isFloat = true;\n      next = this.input.charCodeAt(this.state.pos);\n    }\n\n    if (\n      (next === charCodes.uppercaseE || next === charCodes.lowercaseE) &&\n      !isOctal\n    ) {\n      next = this.input.charCodeAt(++this.state.pos);\n      if (next === charCodes.plusSign || next === charCodes.dash) {\n        ++this.state.pos;\n      }\n      if (this.readInt(10) === null) {\n        this.raise(Errors.InvalidOrMissingExponent, { at: startLoc });\n      }\n      isFloat = true;\n      hasExponent = true;\n      next = this.input.charCodeAt(this.state.pos);\n    }\n\n    if (next === charCodes.lowercaseN) {\n      // disallow floats, legacy octal syntax and non octal decimals\n      // new style octal (\"0o\") is handled in this.readRadixNumber\n      if (isFloat || hasLeadingZero) {\n        this.raise(Errors.InvalidBigIntLiteral, { at: startLoc });\n      }\n      ++this.state.pos;\n      isBigInt = true;\n    }\n\n    if (next === charCodes.lowercaseM) {\n      this.expectPlugin(\"decimal\", this.state.curPosition());\n      if (hasExponent || hasLeadingZero) {\n        this.raise(Errors.InvalidDecimal, { at: startLoc });\n      }\n      ++this.state.pos;\n      isDecimal = true;\n    }\n\n    if (isIdentifierStart(this.codePointAtPos(this.state.pos))) {\n      throw this.raise(Errors.NumberIdentifier, {\n        at: this.state.curPosition(),\n      });\n    }\n\n    // remove \"_\" for numeric literal separator, and trailing `m` or `n`\n    const str = this.input.slice(start, this.state.pos).replace(/[_mn]/g, \"\");\n\n    if (isBigInt) {\n      this.finishToken(tt.bigint, str);\n      return;\n    }\n\n    if (isDecimal) {\n      this.finishToken(tt.decimal, str);\n      return;\n    }\n\n    const val = isOctal ? parseInt(str, 8) : parseFloat(str);\n    this.finishToken(tt.num, val);\n  }\n\n  // Read a string value, interpreting backslash-escapes.\n\n  readCodePoint(throwOnInvalid: boolean): number | null {\n    const { code, pos } = readCodePoint(\n      this.input,\n      this.state.pos,\n      this.state.lineStart,\n      this.state.curLine,\n      throwOnInvalid,\n      this.errorHandlers_readCodePoint,\n    );\n    this.state.pos = pos;\n    return code;\n  }\n\n  readString(quote: number): void {\n    const { str, pos, curLine, lineStart } = readStringContents(\n      quote === charCodes.quotationMark ? \"double\" : \"single\",\n      this.input,\n      this.state.pos + 1, // skip the quote\n      this.state.lineStart,\n      this.state.curLine,\n      this.errorHandlers_readStringContents_string,\n    );\n    this.state.pos = pos + 1; // skip the quote\n    this.state.lineStart = lineStart;\n    this.state.curLine = curLine;\n    this.finishToken(tt.string, str);\n  }\n\n  // Reads template continuation `}...`\n  readTemplateContinuation(): void {\n    if (!this.match(tt.braceR)) {\n      this.unexpected(null, tt.braceR);\n    }\n    // rewind pos to `}`\n    this.state.pos--;\n    this.readTemplateToken();\n  }\n\n  // Reads template string tokens.\n  readTemplateToken(): void {\n    const opening = this.input[this.state.pos];\n    const { str, firstInvalidLoc, pos, curLine, lineStart } =\n      readStringContents(\n        \"template\",\n        this.input,\n        this.state.pos + 1, // skip '`' or `}`\n        this.state.lineStart,\n        this.state.curLine,\n        this.errorHandlers_readStringContents_template,\n      );\n    this.state.pos = pos + 1; // skip '`' or `$`\n    this.state.lineStart = lineStart;\n    this.state.curLine = curLine;\n\n    if (firstInvalidLoc) {\n      this.state.firstInvalidTemplateEscapePos = new Position(\n        firstInvalidLoc.curLine,\n        firstInvalidLoc.pos - firstInvalidLoc.lineStart,\n        firstInvalidLoc.pos,\n      );\n    }\n\n    if (this.input.codePointAt(pos) === charCodes.graveAccent) {\n      this.finishToken(\n        tt.templateTail,\n        firstInvalidLoc ? null : opening + str + \"`\",\n      );\n    } else {\n      this.state.pos++; // skip '{'\n      this.finishToken(\n        tt.templateNonTail,\n        firstInvalidLoc ? null : opening + str + \"${\",\n      );\n    }\n  }\n\n  recordStrictModeErrors(\n    toParseError: DeferredStrictError,\n    { at }: { at: Position },\n  ) {\n    const index = at.index;\n\n    if (this.state.strict && !this.state.strictErrors.has(index)) {\n      this.raise(toParseError, { at });\n    } else {\n      this.state.strictErrors.set(index, [toParseError, at]);\n    }\n  }\n\n  // Read an identifier, and return it as a string. Sets `this.state.containsEsc`\n  // to whether the word contained a '\\u' escape.\n  //\n  // Incrementally adds only escaped chars, adding other chunks as-is\n  // as a micro-optimization.\n  //\n  // When `firstCode` is given, it assumes it is always an identifier start and\n  // will skip reading start position again\n\n  readWord1(firstCode?: number): string {\n    this.state.containsEsc = false;\n    let word = \"\";\n    const start = this.state.pos;\n    let chunkStart = this.state.pos;\n    if (firstCode !== undefined) {\n      this.state.pos += firstCode <= 0xffff ? 1 : 2;\n    }\n\n    while (this.state.pos < this.length) {\n      const ch = this.codePointAtPos(this.state.pos);\n      if (isIdentifierChar(ch)) {\n        this.state.pos += ch <= 0xffff ? 1 : 2;\n      } else if (ch === charCodes.backslash) {\n        this.state.containsEsc = true;\n\n        word += this.input.slice(chunkStart, this.state.pos);\n        const escStart = this.state.curPosition();\n        const identifierCheck =\n          this.state.pos === start ? isIdentifierStart : isIdentifierChar;\n\n        if (this.input.charCodeAt(++this.state.pos) !== charCodes.lowercaseU) {\n          this.raise(Errors.MissingUnicodeEscape, {\n            at: this.state.curPosition(),\n          });\n          chunkStart = this.state.pos - 1;\n          continue;\n        }\n\n        ++this.state.pos;\n        const esc = this.readCodePoint(true);\n        if (esc !== null) {\n          if (!identifierCheck(esc)) {\n            this.raise(Errors.EscapedCharNotAnIdentifier, { at: escStart });\n          }\n\n          word += String.fromCodePoint(esc);\n        }\n        chunkStart = this.state.pos;\n      } else {\n        break;\n      }\n    }\n    return word + this.input.slice(chunkStart, this.state.pos);\n  }\n\n  // Read an identifier or keyword token. Will check for reserved\n  // words when necessary.\n\n  readWord(firstCode?: number): void {\n    const word = this.readWord1(firstCode);\n    const type = keywordTypes.get(word);\n    if (type !== undefined) {\n      // We don't use word as state.value here because word is a dynamic string\n      // while token label is a shared constant string\n      this.finishToken(type, tokenLabelName(type));\n    } else {\n      this.finishToken(tt.name, word);\n    }\n  }\n\n  checkKeywordEscapes(): void {\n    const { type } = this.state;\n    if (tokenIsKeyword(type) && this.state.containsEsc) {\n      this.raise(Errors.InvalidEscapedReservedWord, {\n        at: this.state.startLoc,\n        reservedWord: tokenLabelName(type),\n      });\n    }\n  }\n\n  /**\n   * Raise a `ParseError` given the appropriate properties. If passed a\n   * `Position` for the `at` property, raises the `ParseError` at that location.\n   * Otherwise, if passed a `Node`, raises the `ParseError` at the start\n   * location of that `Node`.\n   *\n   * If `errorRecovery` is `true`, the error is pushed to the errors array and\n   * returned. If `errorRecovery` is `false`, the error is instead thrown.\n   */\n  raise<ErrorDetails>(\n    toParseError: ParseErrorConstructor<ErrorDetails>,\n    raiseProperties: RaiseProperties<ErrorDetails>,\n  ): ParseError<ErrorDetails> {\n    const { at, ...details } = raiseProperties;\n    const loc = at instanceof Position ? at : at.loc.start;\n    // @ts-expect-error: refine details typing\n    const error = toParseError({ loc, details });\n\n    if (!this.options.errorRecovery) throw error;\n    if (!this.isLookahead) this.state.errors.push(error);\n\n    return error;\n  }\n\n  /**\n   * If `errorRecovery` is `false`, this method behaves identically to `raise`.\n   * If `errorRecovery` is `true`, this method will first see if there is\n   * already an error stored at the same `Position`, and replaces it with the\n   * one generated here.\n   */\n  raiseOverwrite<ErrorDetails>(\n    toParseError: ParseErrorConstructor<ErrorDetails>,\n    raiseProperties: RaiseProperties<ErrorDetails>,\n  ): ParseError<ErrorDetails> | never {\n    const { at, ...details } = raiseProperties;\n    const loc = at instanceof Position ? at : at.loc.start;\n    const pos = loc.index;\n    const errors = this.state.errors;\n\n    for (let i = errors.length - 1; i >= 0; i--) {\n      const error = errors[i];\n      if (error.loc.index === pos) {\n        // @ts-expect-error: refine details typing\n        return (errors[i] = toParseError({ loc, details }));\n      }\n      if (error.loc.index < pos) break;\n    }\n\n    return this.raise(toParseError, raiseProperties);\n  }\n\n  // updateContext is used by the jsx plugin\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  updateContext(prevType: TokenType): void {}\n\n  // Raise an unexpected token error. Can take the expected token type.\n  unexpected(loc?: Position | null, type?: TokenType): void {\n    throw this.raise(Errors.UnexpectedToken, {\n      expected: type ? tokenLabelName(type) : null,\n      at: loc != null ? loc : this.state.startLoc,\n    });\n  }\n\n  expectPlugin(pluginName: Plugin, loc?: Position): true {\n    if (this.hasPlugin(pluginName)) {\n      return true;\n    }\n\n    throw this.raise(Errors.MissingPlugin, {\n      at: loc != null ? loc : this.state.startLoc,\n      missingPlugin: [pluginName],\n    });\n  }\n\n  expectOnePlugin(pluginNames: Plugin[]): void {\n    if (!pluginNames.some(name => this.hasPlugin(name))) {\n      throw this.raise(Errors.MissingOneOfPlugins, {\n        at: this.state.startLoc,\n        missingPlugin: pluginNames,\n      });\n    }\n  }\n\n  errorBuilder(error: ParseErrorConstructor<{}>) {\n    return (pos: number, lineStart: number, curLine: number) => {\n      this.raise(error, {\n        at: buildPosition(pos, lineStart, curLine),\n      });\n    };\n  }\n\n  errorHandlers_readInt: IntErrorHandlers = {\n    invalidDigit: (pos, lineStart, curLine, radix) => {\n      if (!this.options.errorRecovery) return false;\n\n      this.raise(Errors.InvalidDigit, {\n        at: buildPosition(pos, lineStart, curLine),\n        radix,\n      });\n      // Continue parsing the number as if there was no invalid digit.\n      return true;\n    },\n    numericSeparatorInEscapeSequence: this.errorBuilder(\n      Errors.NumericSeparatorInEscapeSequence,\n    ),\n    unexpectedNumericSeparator: this.errorBuilder(\n      Errors.UnexpectedNumericSeparator,\n    ),\n  };\n\n  errorHandlers_readCodePoint: CodePointErrorHandlers = {\n    ...this.errorHandlers_readInt,\n    invalidEscapeSequence: this.errorBuilder(Errors.InvalidEscapeSequence),\n    invalidCodePoint: this.errorBuilder(Errors.InvalidCodePoint),\n  };\n\n  errorHandlers_readStringContents_string: StringContentsErrorHandlers = {\n    ...this.errorHandlers_readCodePoint,\n    strictNumericEscape: (pos, lineStart, curLine) => {\n      this.recordStrictModeErrors(Errors.StrictNumericEscape, {\n        at: buildPosition(pos, lineStart, curLine),\n      });\n    },\n    unterminated: (pos, lineStart, curLine) => {\n      throw this.raise(Errors.UnterminatedString, {\n        // Report the error at the string quote\n        at: buildPosition(pos - 1, lineStart, curLine),\n      });\n    },\n  };\n\n  errorHandlers_readStringContents_template: StringContentsErrorHandlers = {\n    ...this.errorHandlers_readCodePoint,\n    strictNumericEscape: this.errorBuilder(Errors.StrictNumericEscape),\n    unterminated: (pos, lineStart, curLine) => {\n      throw this.raise(Errors.UnterminatedTemplate, {\n        at: buildPosition(pos, lineStart, curLine),\n      });\n    },\n  };\n}\n","import {\n  CLASS_ELEMENT_KIND_ACCESSOR,\n  CLASS_ELEMENT_FLAG_STATIC,\n  type ClassElementTypes,\n} from \"./scopeflags\";\nimport type { Position } from \"./location\";\nimport { Errors } from \"../parse-error\";\nimport type Tokenizer from \"../tokenizer\";\n\nexport class ClassScope {\n  // A list of private named declared in the current class\n  privateNames: Set<string> = new Set();\n\n  // A list of private getters of setters without their counterpart\n  loneAccessors: Map<string, ClassElementTypes> = new Map();\n\n  // A list of private names used before being defined, mapping to\n  // their position.\n  undefinedPrivateNames: Map<string, Position> = new Map();\n}\n\nexport default class ClassScopeHandler {\n  parser: Tokenizer;\n  stack: Array<ClassScope> = [];\n  undefinedPrivateNames: Map<string, Position> = new Map();\n\n  constructor(parser: Tokenizer) {\n    this.parser = parser;\n  }\n\n  current(): ClassScope {\n    return this.stack[this.stack.length - 1];\n  }\n\n  enter() {\n    this.stack.push(new ClassScope());\n  }\n\n  exit() {\n    const oldClassScope = this.stack.pop();\n\n    // Migrate the usage of not yet defined private names to the outer\n    // class scope, or raise an error if we reached the top-level scope.\n\n    const current = this.current();\n\n    // Array.from is needed because this is compiled to an array-like for loop\n    for (const [name, loc] of Array.from(oldClassScope.undefinedPrivateNames)) {\n      if (current) {\n        if (!current.undefinedPrivateNames.has(name)) {\n          current.undefinedPrivateNames.set(name, loc);\n        }\n      } else {\n        this.parser.raise(Errors.InvalidPrivateFieldResolution, {\n          at: loc,\n          identifierName: name,\n        });\n      }\n    }\n  }\n\n  declarePrivateName(\n    name: string,\n    elementType: ClassElementTypes,\n    loc: Position,\n  ) {\n    const { privateNames, loneAccessors, undefinedPrivateNames } =\n      this.current();\n    let redefined = privateNames.has(name);\n\n    if (elementType & CLASS_ELEMENT_KIND_ACCESSOR) {\n      const accessor = redefined && loneAccessors.get(name);\n      if (accessor) {\n        const oldStatic = accessor & CLASS_ELEMENT_FLAG_STATIC;\n        const newStatic = elementType & CLASS_ELEMENT_FLAG_STATIC;\n\n        const oldKind = accessor & CLASS_ELEMENT_KIND_ACCESSOR;\n        const newKind = elementType & CLASS_ELEMENT_KIND_ACCESSOR;\n\n        // The private name can be duplicated only if it is used by\n        // two accessors with different kind (get and set), and if\n        // they have the same placement (static or not).\n        redefined = oldKind === newKind || oldStatic !== newStatic;\n\n        if (!redefined) loneAccessors.delete(name);\n      } else if (!redefined) {\n        loneAccessors.set(name, elementType);\n      }\n    }\n\n    if (redefined) {\n      this.parser.raise(Errors.PrivateNameRedeclaration, {\n        at: loc,\n        identifierName: name,\n      });\n    }\n\n    privateNames.add(name);\n    undefinedPrivateNames.delete(name);\n  }\n\n  usePrivateName(name: string, loc: Position) {\n    let classScope;\n    for (classScope of this.stack) {\n      if (classScope.privateNames.has(name)) return;\n    }\n\n    if (classScope) {\n      classScope.undefinedPrivateNames.set(name, loc);\n    } else {\n      // top-level\n      this.parser.raise(Errors.InvalidPrivateFieldResolution, {\n        at: loc,\n        identifierName: name,\n      });\n    }\n  }\n}\n","import { Errors, type ParseErrorConstructor } from \"../parse-error\";\nimport type { Position } from \"./location\";\nimport type { Node } from \"../types\";\nimport type Tokenizer from \"../tokenizer\";\n\n/**\n * @module util/expression-scope\n\nExpressionScope is used to track declaration errors in these ambiguous patterns:\n\n- CoverParenthesizedExpressionAndArrowParameterList\n  e.g. we don't know if `({ x })` is an parenthesized expression or an\n  arrow function parameters until we see an `=>` after `)`.\n\n- CoverCallExpressionAndAsyncArrowHead\n  e.g. we don't know if `async({ x })` is a call expression or an async arrow\n  function parameters until we see an `=>` after `)`\n\nThe following declaration errors (@see parser-errors/standard) will be recorded in\nsome expression scopes and thrown later when we know what the ambiguous pattern is\n\n- AwaitBindingIdentifier\n- AwaitExpressionFormalParameter\n- YieldInParameter\n- InvalidParenthesizedAssignment when parenthesized is an identifier\n\nThere are four different expression scope\n- Expression\n  A general scope that represents program / function body / static block. No errors\n  will be recorded nor thrown in this scope.\n\n- MaybeArrowParameterDeclaration\n  A scope that represents ambiguous arrow head e.g. `(x)`. Errors will be recorded\n  alongside parent scopes and thrown when `ExpressionScopeHandler#validateAsPattern`\n  is called.\n\n- MaybeAsyncArrowParameterDeclaration\n  A scope that represents ambiguous async arrow head e.g. `async(x)`. Errors will\n  be recorded alongside parent scopes and thrown when\n  `ExpressionScopeHandler#validateAsPattern` is called.\n\n- ParameterDeclaration\n  A scope that represents unambiguous function parameters `function(x)`. Errors\n  recorded in this scope will be thrown immediately. No errors will be recorded in\n  this scope.\n\n// @see {@link https://docs.google.com/document/d/1FAvEp9EUK-G8kHfDIEo_385Hs2SUBCYbJ5H-NnLvq8M|V8 Expression Scope design docs}\n */\n\nconst kExpression = 0,\n  kMaybeArrowParameterDeclaration = 1,\n  kMaybeAsyncArrowParameterDeclaration = 2,\n  kParameterDeclaration = 3;\n\ntype ExpressionScopeType = 0 | 1 | 2 | 3;\n\nclass ExpressionScope {\n  type: ExpressionScopeType;\n\n  constructor(type: ExpressionScopeType = kExpression) {\n    this.type = type;\n  }\n\n  canBeArrowParameterDeclaration(): this is ArrowHeadParsingScope {\n    return (\n      this.type === kMaybeAsyncArrowParameterDeclaration ||\n      this.type === kMaybeArrowParameterDeclaration\n    );\n  }\n\n  isCertainlyParameterDeclaration() {\n    return this.type === kParameterDeclaration;\n  }\n}\n\ntype ArrowHeadParsingParameterInitializerError =\n  | typeof Errors.AwaitExpressionFormalParameter\n  | typeof Errors.YieldInParameter;\ntype ArrowHeadParsingDeclarationError =\n  | ArrowHeadParsingParameterInitializerError\n  | typeof Errors.InvalidParenthesizedAssignment\n  | typeof Errors.AwaitBindingIdentifier;\n\nclass ArrowHeadParsingScope extends ExpressionScope {\n  declarationErrors: Map<number, [ParseErrorConstructor<{}>, Position]> =\n    new Map();\n  constructor(type: 1 | 2) {\n    super(type);\n  }\n  recordDeclarationError(\n    ParsingErrorClass: ParseErrorConstructor<{}>,\n    {\n      at,\n    }: {\n      at: Position;\n    },\n  ) {\n    const index = at.index;\n\n    this.declarationErrors.set(index, [ParsingErrorClass, at]);\n  }\n  clearDeclarationError(index: number) {\n    this.declarationErrors.delete(index);\n  }\n  iterateErrors(\n    iterator: (a: [ArrowHeadParsingDeclarationError, Position]) => void,\n  ) {\n    this.declarationErrors.forEach(iterator);\n  }\n}\n\nexport default class ExpressionScopeHandler {\n  parser: Tokenizer;\n  stack: Array<ExpressionScope> = [new ExpressionScope()];\n\n  constructor(parser: Tokenizer) {\n    this.parser = parser;\n  }\n  enter(scope: ExpressionScope) {\n    this.stack.push(scope);\n  }\n\n  exit() {\n    this.stack.pop();\n  }\n\n  /**\n   * Record likely parameter initializer errors\n   *\n   * When current scope is a ParameterDeclaration, the error will be thrown immediately,\n   * otherwise it will be recorded to any ancestry MaybeArrowParameterDeclaration and\n   * MaybeAsyncArrowParameterDeclaration scope until an Expression scope is seen.\n   */\n  recordParameterInitializerError(\n    toParseError: ArrowHeadParsingParameterInitializerError,\n    {\n      at: node,\n    }: {\n      at: Node;\n    },\n  ): void {\n    const origin = { at: node.loc.start };\n    const { stack } = this;\n    let i = stack.length - 1;\n    let scope: ExpressionScope = stack[i];\n    while (!scope.isCertainlyParameterDeclaration()) {\n      if (scope.canBeArrowParameterDeclaration()) {\n        scope.recordDeclarationError(toParseError, origin);\n      } else {\n        /*:: invariant(scope.type == kExpression) */\n        // Type-Expression is the boundary where initializer error can populate to\n        return;\n      }\n      scope = stack[--i];\n    }\n    this.parser.raise(toParseError, origin);\n  }\n\n  /**\n   * Record errors that must be thrown if the current pattern ends up being an arrow\n   * function parameter. This is used to record parenthesized identifiers, and to record\n   * \"a as T\" and \"<T> a\" type assertions when parsing typescript.\n   *\n   * A parenthesized identifier (or type assertion) in LHS can be ambiguous because the assignment\n   * can be transformed to an assignable later, but not vice versa:\n   * For example, in `([(a) = []] = []) => {}`, we think `(a) = []` is an LHS in `[(a) = []]`,\n   * an LHS within `[(a) = []] = []`. However the LHS chain is then transformed by toAssignable,\n   * and we should throw assignment `(a)`, which is only valid in LHS. Hence we record the\n   * location of parenthesized `(a)` to current scope if it is one of MaybeArrowParameterDeclaration\n   * and MaybeAsyncArrowParameterDeclaration\n   *\n   * Unlike `recordParameterInitializerError`, we don't record to ancestry scope because we\n   * validate arrow head parsing scope before exit, and then the LHS will be unambiguous:\n   * For example, in `( x = ( [(a) = []] = [] ) ) => {}`, we should not record `(a)` in `( x = ... ) =>`\n   * arrow scope because when we finish parsing `( [(a) = []] = [] )`, it is an unambiguous assignment\n   * expression and can not be cast to pattern\n   */\n  recordArrowParameterBindingError(\n    error: ParseErrorConstructor<{}>,\n    {\n      at: node,\n    }: {\n      at: Node;\n    },\n  ): void {\n    const { stack } = this;\n    const scope: ExpressionScope = stack[stack.length - 1];\n    const origin = { at: node.loc.start };\n    if (scope.isCertainlyParameterDeclaration()) {\n      this.parser.raise(error, origin);\n    } else if (scope.canBeArrowParameterDeclaration()) {\n      scope.recordDeclarationError(error, origin);\n    } else {\n      return;\n    }\n  }\n\n  /**\n   * Record likely async arrow parameter errors\n   *\n   * Errors will be recorded to any ancestry MaybeAsyncArrowParameterDeclaration\n   * scope until an Expression scope is seen.\n   */\n  recordAsyncArrowParametersError({ at }: { at: Position }): void {\n    const { stack } = this;\n    let i = stack.length - 1;\n    let scope: ExpressionScope = stack[i];\n    while (scope.canBeArrowParameterDeclaration()) {\n      if (scope.type === kMaybeAsyncArrowParameterDeclaration) {\n        scope.recordDeclarationError(Errors.AwaitBindingIdentifier, { at });\n      }\n      scope = stack[--i];\n    }\n  }\n\n  validateAsPattern(): void {\n    const { stack } = this;\n    const currentScope = stack[stack.length - 1];\n    if (!currentScope.canBeArrowParameterDeclaration()) return;\n    currentScope.iterateErrors(([toParseError, loc]) => {\n      this.parser.raise(toParseError, { at: loc });\n      // iterate from parent scope\n      let i = stack.length - 2;\n      let scope = stack[i];\n      while (scope.canBeArrowParameterDeclaration()) {\n        scope.clearDeclarationError(loc.index);\n        scope = stack[--i];\n      }\n    });\n  }\n}\n\nexport function newParameterDeclarationScope() {\n  return new ExpressionScope(kParameterDeclaration);\n}\n\nexport function newArrowHeadScope() {\n  return new ArrowHeadParsingScope(kMaybeArrowParameterDeclaration);\n}\n\nexport function newAsyncArrowScope() {\n  return new ArrowHeadParsingScope(kMaybeAsyncArrowParameterDeclaration);\n}\n\nexport function newExpressionScope() {\n  return new ExpressionScope();\n}\n","export const // Initial Parameter flags\n  PARAM = 0b0000,\n  // track [Yield] production parameter\n  PARAM_YIELD = 0b0001,\n  // track [Await] production parameter\n  PARAM_AWAIT = 0b0010,\n  // track [Return] production parameter\n  PARAM_RETURN = 0b0100,\n  PARAM_IN = 0b1000; // track [In] production parameter\n\n// ProductionParameterHandler is a stack fashioned production parameter tracker\n// https://tc39.es/ecma262/#sec-grammar-notation\n// The tracked parameters are defined above.\n//\n// Whenever [+Await]/[+Yield] appears in the right-hand sides of a production,\n// we must enter a new tracking stack. For example when parsing\n//\n// AsyncFunctionDeclaration [Yield, Await]:\n//   async [no LineTerminator here] function BindingIdentifier[?Yield, ?Await]\n//     ( FormalParameters[~Yield, +Await] ) { AsyncFunctionBody }\n//\n// we must follow such process:\n//\n// 1. parse async keyword\n// 2. parse function keyword\n// 3. parse bindingIdentifier <= inherit current parameters: [?Await]\n// 4. enter new stack with (PARAM_AWAIT)\n// 5. parse formal parameters <= must have [Await] parameter [+Await]\n// 6. parse function body\n// 7. exit current stack\n\nexport type ParamKind = number;\n\n// todo(flow->ts) - check if more granular type can be used,\n//  type below is not good because things like PARAM_AWAIT|PARAM_YIELD are not included\n// export type ParamKind =\n//   | typeof PARAM\n//   | typeof PARAM_AWAIT\n//   | typeof PARAM_IN\n//   | typeof PARAM_RETURN\n//   | typeof PARAM_YIELD;\n\nexport default class ProductionParameterHandler {\n  stacks: Array<number> = [];\n  enter(flags: number) {\n    this.stacks.push(flags);\n  }\n\n  exit() {\n    this.stacks.pop();\n  }\n\n  currentFlags(): number {\n    return this.stacks[this.stacks.length - 1];\n  }\n\n  get hasAwait(): boolean {\n    return (this.currentFlags() & PARAM_AWAIT) > 0;\n  }\n\n  get hasYield(): boolean {\n    return (this.currentFlags() & PARAM_YIELD) > 0;\n  }\n\n  get hasReturn(): boolean {\n    return (this.currentFlags() & PARAM_RETURN) > 0;\n  }\n\n  get hasIn(): boolean {\n    return (this.currentFlags() & PARAM_IN) > 0;\n  }\n}\n\nexport function functionFlags(\n  isAsync: boolean,\n  isGenerator: boolean,\n): ParamKind {\n  return (isAsync ? PARAM_AWAIT : 0) | (isGenerator ? PARAM_YIELD : 0);\n}\n","import type { Position } from \"../util/location\";\nimport {\n  tokenIsLiteralPropertyName,\n  tt,\n  type TokenType,\n} from \"../tokenizer/types\";\nimport Tokenizer from \"../tokenizer\";\nimport type State from \"../tokenizer/state\";\nimport type { EstreePropertyDefinition, Node, ObjectProperty } from \"../types\";\nimport { lineBreak, skipWhiteSpaceToLineBreak } from \"../util/whitespace\";\nimport { isIdentifierChar } from \"../util/identifier\";\nimport ClassScopeHandler from \"../util/class-scope\";\nimport ExpressionScopeHandler from \"../util/expression-scope\";\nimport { SCOPE_PROGRAM } from \"../util/scopeflags\";\nimport ProductionParameterHandler, {\n  PARAM_AWAIT,\n  PARAM,\n} from \"../util/production-parameter\";\nimport {\n  Errors,\n  type ParseError,\n  type ParseErrorConstructor,\n} from \"../parse-error\";\nimport type Parser from \".\";\n\nimport type ScopeHandler from \"../util/scope\";\n\ntype TryParse<Node, Error, Thrown, Aborted, FailState> = {\n  node: Node;\n  error: Error;\n  thrown: Thrown;\n  aborted: Aborted;\n  failState: FailState;\n};\n\n// ## Parser utilities\n\nexport default abstract class UtilParser extends Tokenizer {\n  // Forward-declaration: defined in parser/index.js\n  abstract getScopeHandler(): { new (...args: any): ScopeHandler };\n\n  addExtra(\n    node: Partial<Node>,\n    key: string,\n    value: any,\n    enumerable: boolean = true,\n  ): void {\n    if (!node) return;\n\n    const extra = (node.extra = node.extra || {});\n    if (enumerable) {\n      extra[key] = value;\n    } else {\n      Object.defineProperty(extra, key, { enumerable, value });\n    }\n  }\n\n  // Tests whether parsed token is a contextual keyword.\n\n  isContextual(token: TokenType): boolean {\n    return this.state.type === token && !this.state.containsEsc;\n  }\n\n  isUnparsedContextual(nameStart: number, name: string): boolean {\n    const nameEnd = nameStart + name.length;\n    if (this.input.slice(nameStart, nameEnd) === name) {\n      const nextCh = this.input.charCodeAt(nameEnd);\n      return !(\n        isIdentifierChar(nextCh) ||\n        // check if `nextCh is between 0xd800 - 0xdbff,\n        // if `nextCh` is NaN, `NaN & 0xfc00` is 0, the function\n        // returns true\n        (nextCh & 0xfc00) === 0xd800\n      );\n    }\n    return false;\n  }\n\n  isLookaheadContextual(name: string): boolean {\n    const next = this.nextTokenStart();\n    return this.isUnparsedContextual(next, name);\n  }\n\n  // Consumes contextual keyword if possible.\n\n  eatContextual(token: TokenType): boolean {\n    if (this.isContextual(token)) {\n      this.next();\n      return true;\n    }\n    return false;\n  }\n\n  // Asserts that following token is given contextual keyword.\n\n  expectContextual(\n    token: TokenType,\n    toParseError?: ParseErrorConstructor<any>,\n  ): void {\n    if (!this.eatContextual(token)) {\n      if (toParseError != null) {\n        throw this.raise(toParseError, { at: this.state.startLoc });\n      }\n      this.unexpected(null, token);\n    }\n  }\n\n  // Test whether a semicolon can be inserted at the current position.\n\n  canInsertSemicolon(): boolean {\n    return (\n      this.match(tt.eof) ||\n      this.match(tt.braceR) ||\n      this.hasPrecedingLineBreak()\n    );\n  }\n\n  hasPrecedingLineBreak(): boolean {\n    return lineBreak.test(\n      this.input.slice(this.state.lastTokEndLoc.index, this.state.start),\n    );\n  }\n\n  hasFollowingLineBreak(): boolean {\n    skipWhiteSpaceToLineBreak.lastIndex = this.state.end;\n    return skipWhiteSpaceToLineBreak.test(this.input);\n  }\n\n  isLineTerminator(): boolean {\n    return this.eat(tt.semi) || this.canInsertSemicolon();\n  }\n\n  // Consume a semicolon, or, failing that, see if we are allowed to\n  // pretend that there is a semicolon at this position.\n\n  semicolon(allowAsi: boolean = true): void {\n    if (allowAsi ? this.isLineTerminator() : this.eat(tt.semi)) return;\n    this.raise(Errors.MissingSemicolon, { at: this.state.lastTokEndLoc });\n  }\n\n  // Expect a token of a given type. If found, consume it, otherwise,\n  // raise an unexpected token error at given pos.\n\n  expect(type: TokenType, loc?: Position | null): void {\n    this.eat(type) || this.unexpected(loc, type);\n  }\n\n  // tryParse will clone parser state.\n  // It is expensive and should be used with cautions\n  tryParse<T extends Node | ReadonlyArray<Node>>(\n    fn: (abort: (node?: T) => never) => T,\n    oldState: State = this.state.clone(),\n  ):\n    | TryParse<T, null, false, false, null>\n    | TryParse<T | null, ParseError<any>, boolean, false, State>\n    | TryParse<T | null, null, false, true, State> {\n    const abortSignal: {\n      node: T | null;\n    } = { node: null };\n    try {\n      const node = fn((node = null) => {\n        abortSignal.node = node;\n        throw abortSignal;\n      });\n      if (this.state.errors.length > oldState.errors.length) {\n        const failState = this.state;\n        this.state = oldState;\n        // tokensLength should be preserved during error recovery mode\n        // since the parser does not halt and will instead parse the\n        // remaining tokens\n        this.state.tokensLength = failState.tokensLength;\n        return {\n          node,\n          error: failState.errors[oldState.errors.length],\n          thrown: false,\n          aborted: false,\n          failState,\n        };\n      }\n\n      return {\n        node,\n        error: null,\n        thrown: false,\n        aborted: false,\n        failState: null,\n      };\n    } catch (error) {\n      const failState = this.state;\n      this.state = oldState;\n      if (error instanceof SyntaxError) {\n        // @ts-expect-error casting general syntax error to parse error\n        return { node: null, error, thrown: true, aborted: false, failState };\n      }\n      if (error === abortSignal) {\n        return {\n          node: abortSignal.node,\n          error: null,\n          thrown: false,\n          aborted: true,\n          failState,\n        };\n      }\n\n      throw error;\n    }\n  }\n\n  checkExpressionErrors(\n    refExpressionErrors: ExpressionErrors | undefined | null,\n    andThrow: boolean,\n  ) {\n    if (!refExpressionErrors) return false;\n    const {\n      shorthandAssignLoc,\n      doubleProtoLoc,\n      privateKeyLoc,\n      optionalParametersLoc,\n    } = refExpressionErrors;\n\n    const hasErrors =\n      !!shorthandAssignLoc ||\n      !!doubleProtoLoc ||\n      !!optionalParametersLoc ||\n      !!privateKeyLoc;\n\n    if (!andThrow) {\n      return hasErrors;\n    }\n\n    if (shorthandAssignLoc != null) {\n      this.raise(Errors.InvalidCoverInitializedName, {\n        at: shorthandAssignLoc,\n      });\n    }\n\n    if (doubleProtoLoc != null) {\n      this.raise(Errors.DuplicateProto, { at: doubleProtoLoc });\n    }\n\n    if (privateKeyLoc != null) {\n      this.raise(Errors.UnexpectedPrivateField, { at: privateKeyLoc });\n    }\n\n    if (optionalParametersLoc != null) {\n      this.unexpected(optionalParametersLoc);\n    }\n  }\n\n  /**\n   * Test if current token is a literal property name\n   * https://tc39.es/ecma262/#prod-LiteralPropertyName\n   * LiteralPropertyName:\n   *   IdentifierName\n   *   StringLiteral\n   *   NumericLiteral\n   *   BigIntLiteral\n   */\n  isLiteralPropertyName(): boolean {\n    return tokenIsLiteralPropertyName(this.state.type);\n  }\n\n  /**\n   * Test if given node is a PrivateName\n   * will be overridden in ESTree plugin\n   */\n  isPrivateName(node: Node): boolean {\n    return node.type === \"PrivateName\";\n  }\n\n  /**\n   * Return the string value of a given private name\n   * WITHOUT `#`\n   * @see {@link https://tc39.es/ecma262/#sec-static-semantics-stringvalue}\n   */\n  getPrivateNameSV(node: Node): string {\n    return node.id.name;\n  }\n\n  /**\n   * Return whether the given node is a member/optional chain that\n   * contains a private name as its property\n   * It is overridden in ESTree plugin\n   */\n  hasPropertyAsPrivateName(node: Node): boolean {\n    return (\n      (node.type === \"MemberExpression\" ||\n        node.type === \"OptionalMemberExpression\") &&\n      this.isPrivateName(node.property)\n    );\n  }\n\n  isObjectProperty(\n    node: Node,\n  ): node is ObjectProperty | EstreePropertyDefinition {\n    return node.type === \"ObjectProperty\";\n  }\n\n  isObjectMethod(node: Node): boolean {\n    return node.type === \"ObjectMethod\";\n  }\n\n  initializeScopes(\n    this: Parser,\n    inModule: boolean = this.options.sourceType === \"module\",\n  ): () => void {\n    // Initialize state\n    const oldLabels = this.state.labels;\n    this.state.labels = [];\n\n    const oldExportedIdentifiers = this.exportedIdentifiers;\n    this.exportedIdentifiers = new Set();\n\n    // initialize scopes\n    const oldInModule = this.inModule;\n    this.inModule = inModule;\n\n    const oldScope = this.scope;\n    const ScopeHandler = this.getScopeHandler();\n    this.scope = new ScopeHandler(this, inModule);\n\n    const oldProdParam = this.prodParam;\n    this.prodParam = new ProductionParameterHandler();\n\n    const oldClassScope = this.classScope;\n    this.classScope = new ClassScopeHandler(this);\n\n    const oldExpressionScope = this.expressionScope;\n    this.expressionScope = new ExpressionScopeHandler(this);\n\n    return () => {\n      // Revert state\n      this.state.labels = oldLabels;\n      this.exportedIdentifiers = oldExportedIdentifiers;\n\n      // Revert scopes\n      this.inModule = oldInModule;\n      this.scope = oldScope;\n      this.prodParam = oldProdParam;\n      this.classScope = oldClassScope;\n      this.expressionScope = oldExpressionScope;\n    };\n  }\n\n  enterInitialScopes() {\n    let paramFlags = PARAM;\n    if (this.inModule) {\n      paramFlags |= PARAM_AWAIT;\n    }\n    this.scope.enter(SCOPE_PROGRAM);\n    this.prodParam.enter(paramFlags);\n  }\n\n  checkDestructuringPrivate(refExpressionErrors: ExpressionErrors) {\n    const { privateKeyLoc } = refExpressionErrors;\n    if (privateKeyLoc !== null) {\n      this.expectPlugin(\"destructuringPrivate\", privateKeyLoc);\n    }\n  }\n}\n\n/**\n * The ExpressionErrors is a context struct used to track ambiguous patterns\n * When we are sure the parsed pattern is a RHS, which means it is not a pattern,\n * we will throw on this position on invalid assign syntax, otherwise it will be reset to -1\n *\n * Types of ExpressionErrors:\n *\n * - **shorthandAssignLoc**: track initializer `=` position\n * - **doubleProtoLoc**: track the duplicate `__proto__` key position\n * - **privateKey**: track private key `#p` position\n * - **optionalParametersLoc**: track the optional parameter (`?`).\n * It's only used by typescript and flow plugins\n */\nexport class ExpressionErrors {\n  shorthandAssignLoc: Position | undefined | null = null;\n  doubleProtoLoc: Position | undefined | null = null;\n  privateKeyLoc: Position | undefined | null = null;\n  optionalParametersLoc: Position | undefined | null = null;\n}\n","import type Parser from \"./index\";\nimport UtilParser from \"./util\";\nimport { SourceLocation, type Position } from \"../util/location\";\nimport type { Comment, Node as NodeType, NodeBase } from \"../types\";\n\n// Start an AST node, attaching a start offset.\n\nclass Node implements NodeBase {\n  constructor(parser: Parser, pos: number, loc: Position) {\n    this.start = pos;\n    this.end = 0;\n    this.loc = new SourceLocation(loc);\n    if (parser?.options.ranges) this.range = [pos, 0];\n    if (parser?.filename) this.loc.filename = parser.filename;\n  }\n\n  type: string = \"\";\n  declare start: number;\n  declare end: number;\n  declare loc: SourceLocation;\n  declare range: [number, number];\n  declare leadingComments: Array<Comment>;\n  declare trailingComments: Array<Comment>;\n  declare innerComments: Array<Comment>;\n  declare extra: {\n    [key: string]: any;\n  };\n}\nconst NodePrototype = Node.prototype;\n\nif (!process.env.BABEL_8_BREAKING) {\n  // @ts-expect-error __clone is not defined in Node prototype\n  NodePrototype.__clone = function (): Node {\n    const newNode = new Node(undefined, this.start, this.loc.start);\n    const keys = Object.keys(this) as (keyof Node)[];\n    for (let i = 0, length = keys.length; i < length; i++) {\n      const key = keys[i];\n      // Do not clone comments that are already attached to the node\n      if (\n        key !== \"leadingComments\" &&\n        key !== \"trailingComments\" &&\n        key !== \"innerComments\"\n      ) {\n        // @ts-expect-error cloning this to newNode\n        newNode[key] = this[key];\n      }\n    }\n\n    return newNode;\n  };\n}\n\nfunction clonePlaceholder(node: any): any {\n  return cloneIdentifier(node);\n}\n\nexport function cloneIdentifier(node: any): any {\n  // We don't need to clone `typeAnnotations` and `optional`: because\n  // cloneIdentifier is only used in object shorthand and named import/export.\n  // Neither of them allow type annotations after the identifier or optional identifier\n  const { type, start, end, loc, range, extra, name } = node;\n  const cloned = Object.create(NodePrototype);\n  cloned.type = type;\n  cloned.start = start;\n  cloned.end = end;\n  cloned.loc = loc;\n  cloned.range = range;\n  cloned.extra = extra;\n  cloned.name = name;\n  if (type === \"Placeholder\") {\n    cloned.expectedNode = node.expectedNode;\n  }\n  return cloned;\n}\n\nexport function cloneStringLiteral(node: any): any {\n  const { type, start, end, loc, range, extra } = node;\n  if (type === \"Placeholder\") {\n    return clonePlaceholder(node);\n  }\n  const cloned = Object.create(NodePrototype);\n  cloned.type = type;\n  cloned.start = start;\n  cloned.end = end;\n  cloned.loc = loc;\n  cloned.range = range;\n  if (node.raw !== undefined) {\n    // estree set node.raw instead of node.extra\n    cloned.raw = node.raw;\n  } else {\n    cloned.extra = extra;\n  }\n  cloned.value = node.value;\n  return cloned;\n}\n\nexport type Undone<T extends NodeType> = Omit<T, \"type\">;\n\nexport abstract class NodeUtils extends UtilParser {\n  startNode<T extends NodeType>(): Undone<T> {\n    // @ts-expect-error cast Node as Undone<T>\n    return new Node(this, this.state.start, this.state.startLoc);\n  }\n\n  startNodeAt<T extends NodeType>(loc: Position): Undone<T> {\n    // @ts-expect-error cast Node as Undone<T>\n    return new Node(this, loc.index, loc);\n  }\n\n  /** Start a new node with a previous node's location. */\n  startNodeAtNode<T extends NodeType>(type: Undone<NodeType>): Undone<T> {\n    return this.startNodeAt(type.loc.start);\n  }\n\n  // Finish an AST node, adding `type` and `end` properties.\n\n  finishNode<T extends NodeType>(node: Undone<T>, type: T[\"type\"]): T {\n    return this.finishNodeAt(node, type, this.state.lastTokEndLoc);\n  }\n\n  // Finish node at given position\n\n  finishNodeAt<T extends NodeType>(\n    node: Omit<T, \"type\">,\n    type: T[\"type\"],\n    endLoc: Position,\n  ): T {\n    if (process.env.NODE_ENV !== \"production\" && node.end > 0) {\n      throw new Error(\n        \"Do not call finishNode*() twice on the same node.\" +\n          \" Instead use resetEndLocation() or change type directly.\",\n      );\n    }\n    // @ts-expect-error migrate to Babel types AST typings\n    node.type = type;\n    // @ts-expect-error migrate to Babel types AST typings\n    node.end = endLoc.index;\n    node.loc.end = endLoc;\n    if (this.options.ranges) node.range[1] = endLoc.index;\n    if (this.options.attachComment) this.processComment(node as T);\n    return node as T;\n  }\n\n  resetStartLocation(node: NodeBase, startLoc: Position): void {\n    node.start = startLoc.index;\n    node.loc.start = startLoc;\n    if (this.options.ranges) node.range[0] = startLoc.index;\n  }\n\n  resetEndLocation(\n    node: NodeBase,\n    endLoc: Position = this.state.lastTokEndLoc,\n  ): void {\n    node.end = endLoc.index;\n    node.loc.end = endLoc;\n    if (this.options.ranges) node.range[1] = endLoc.index;\n  }\n\n  /**\n   * Reset the start location of node to the start location of locationNode\n   */\n  resetStartLocationFromNode(node: NodeBase, locationNode: NodeBase): void {\n    this.resetStartLocation(node, locationNode.loc.start);\n  }\n}\n","/*:: declare var invariant; */\n\nimport type Parser from \"../../parser\";\nimport {\n  tokenIsIdentifier,\n  tokenIsKeyword,\n  tokenIsKeywordOrIdentifier,\n  tokenIsLiteralPropertyName,\n  tokenLabelName,\n  tt,\n  type TokenType,\n  tokenIsFlowInterfaceOrTypeOrOpaque,\n} from \"../../tokenizer/types\";\nimport type * as N from \"../../types\";\nimport type { Position } from \"../../util/location\";\nimport { types as tc } from \"../../tokenizer/context\";\nimport * as charCodes from \"charcodes\";\nimport { isIteratorStart } from \"../../util/identifier\";\nimport FlowScopeHandler from \"./scope\";\nimport {\n  BIND_LEXICAL,\n  BIND_VAR,\n  BIND_FUNCTION,\n  BIND_FLOW_DECLARE_FN,\n  SCOPE_ARROW,\n  SCOPE_FUNCTION,\n  SCOPE_OTHER,\n  type BindingTypes,\n} from \"../../util/scopeflags\";\nimport type { ExpressionErrors } from \"../../parser/util\";\nimport type { ParseStatementFlag } from \"../../parser/statement\";\nimport { Errors, ParseErrorEnum } from \"../../parse-error\";\nimport { cloneIdentifier, type Undone } from \"../../parser/node\";\n\nconst reservedTypes = new Set([\n  \"_\",\n  \"any\",\n  \"bool\",\n  \"boolean\",\n  \"empty\",\n  \"extends\",\n  \"false\",\n  \"interface\",\n  \"mixed\",\n  \"null\",\n  \"number\",\n  \"static\",\n  \"string\",\n  \"true\",\n  \"typeof\",\n  \"void\",\n]);\n\n/* eslint sort-keys: \"error\" */\n// The Errors key follows https://github.com/facebook/flow/blob/master/src/parser/parse_error.ml unless it does not exist\nconst FlowErrors = ParseErrorEnum`flow`({\n  AmbiguousConditionalArrow:\n    \"Ambiguous expression: wrap the arrow functions in parentheses to disambiguate.\",\n  AmbiguousDeclareModuleKind:\n    \"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.\",\n  // TODO: When we get proper string enums in typescript make this ReservedType.\n  // Not really worth it to do the whole $Values dance with reservedTypes set.\n  AssignReservedType: ({ reservedType }: { reservedType: string }) =>\n    `Cannot overwrite reserved type ${reservedType}.`,\n  DeclareClassElement:\n    \"The `declare` modifier can only appear on class fields.\",\n  DeclareClassFieldInitializer:\n    \"Initializers are not allowed in fields with the `declare` modifier.\",\n  DuplicateDeclareModuleExports:\n    \"Duplicate `declare module.exports` statement.\",\n  EnumBooleanMemberNotInitialized: ({\n    memberName,\n    enumName,\n  }: {\n    memberName: string;\n    enumName: string;\n  }) =>\n    `Boolean enum members need to be initialized. Use either \\`${memberName} = true,\\` or \\`${memberName} = false,\\` in enum \\`${enumName}\\`.`,\n  EnumDuplicateMemberName: ({\n    memberName,\n    enumName,\n  }: {\n    memberName: string;\n    enumName: string;\n  }) =>\n    `Enum member names need to be unique, but the name \\`${memberName}\\` has already been used before in enum \\`${enumName}\\`.`,\n  EnumInconsistentMemberValues: ({ enumName }: { enumName: string }) =>\n    `Enum \\`${enumName}\\` has inconsistent member initializers. Either use no initializers, or consistently use literals (either booleans, numbers, or strings) for all member initializers.`,\n  EnumInvalidExplicitType: ({\n    invalidEnumType,\n    enumName,\n  }: {\n    invalidEnumType: string;\n    enumName: string;\n  }) =>\n    `Enum type \\`${invalidEnumType}\\` is not valid. Use one of \\`boolean\\`, \\`number\\`, \\`string\\`, or \\`symbol\\` in enum \\`${enumName}\\`.`,\n  EnumInvalidExplicitTypeUnknownSupplied: ({\n    enumName,\n  }: {\n    enumName: string;\n  }) =>\n    `Supplied enum type is not valid. Use one of \\`boolean\\`, \\`number\\`, \\`string\\`, or \\`symbol\\` in enum \\`${enumName}\\`.`,\n\n  // TODO: When moving to typescript, we should either have each of the\n  // following errors only accept the specific strings they want:\n  //\n  // ...PrimaryType: explicitType: \"string\" | \"number\" | \"boolean\"\n  // ...SymbolType: explicitType: \"symbol\"\n  // ...UnknownType: explicitType: null\n  //\n  // Or, alternatively, merge these three errors together into one\n  // `EnumInvalidMemberInitializer` error that can accept `EnumExplicitType`\n  // without alteration, and then just have its message change based on the\n  // explicitType.\n  EnumInvalidMemberInitializerPrimaryType: ({\n    enumName,\n    memberName,\n    explicitType,\n  }: {\n    enumName: string;\n    memberName: string;\n    explicitType: EnumExplicitType;\n  }) =>\n    `Enum \\`${enumName}\\` has type \\`${explicitType}\\`, so the initializer of \\`${memberName}\\` needs to be a ${explicitType} literal.`,\n  EnumInvalidMemberInitializerSymbolType: ({\n    enumName,\n    memberName,\n  }: {\n    enumName: string;\n    memberName: string;\n    explicitType: EnumExplicitType;\n  }) =>\n    `Symbol enum members cannot be initialized. Use \\`${memberName},\\` in enum \\`${enumName}\\`.`,\n  EnumInvalidMemberInitializerUnknownType: ({\n    enumName,\n    memberName,\n  }: {\n    enumName: string;\n    memberName: string;\n    explicitType: EnumExplicitType;\n  }) =>\n    `The enum member initializer for \\`${memberName}\\` needs to be a literal (either a boolean, number, or string) in enum \\`${enumName}\\`.`,\n  EnumInvalidMemberName: ({\n    enumName,\n    memberName,\n    suggestion,\n  }: {\n    enumName: string;\n    memberName: string;\n    suggestion: string;\n  }) =>\n    `Enum member names cannot start with lowercase 'a' through 'z'. Instead of using \\`${memberName}\\`, consider using \\`${suggestion}\\`, in enum \\`${enumName}\\`.`,\n  EnumNumberMemberNotInitialized: ({\n    enumName,\n    memberName,\n  }: {\n    enumName: string;\n    memberName: string;\n  }) =>\n    `Number enum members need to be initialized, e.g. \\`${memberName} = 1\\` in enum \\`${enumName}\\`.`,\n  EnumStringMemberInconsistentlyInitailized: ({\n    enumName,\n  }: {\n    enumName: string;\n  }) =>\n    `String enum members need to consistently either all use initializers, or use no initializers, in enum \\`${enumName}\\`.`,\n  GetterMayNotHaveThisParam: \"A getter cannot have a `this` parameter.\",\n  ImportReflectionHasImportType:\n    \"An `import module` declaration can not use `type` or `typeof` keyword.\",\n  ImportTypeShorthandOnlyInPureImport:\n    \"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.\",\n  InexactInsideExact:\n    \"Explicit inexact syntax cannot appear inside an explicit exact object type.\",\n  InexactInsideNonObject:\n    \"Explicit inexact syntax cannot appear in class or interface definitions.\",\n  InexactVariance: \"Explicit inexact syntax cannot have variance.\",\n  InvalidNonTypeImportInDeclareModule:\n    \"Imports within a `declare module` body must always be `import type` or `import typeof`.\",\n  MissingTypeParamDefault:\n    \"Type parameter declaration needs a default, since a preceding type parameter declaration has a default.\",\n  NestedDeclareModule:\n    \"`declare module` cannot be used inside another `declare module`.\",\n  NestedFlowComment: \"Cannot have a flow comment inside another flow comment.\",\n  PatternIsOptional: {\n    message:\n      \"A binding pattern parameter cannot be optional in an implementation signature.\",\n    // For consistency in TypeScript and Flow error codes\n    ...(!process.env.BABEL_8_BREAKING\n      ? { reasonCode: \"OptionalBindingPattern\" }\n      : {}),\n  },\n  SetterMayNotHaveThisParam: \"A setter cannot have a `this` parameter.\",\n  SpreadVariance: \"Spread properties cannot have variance.\",\n  ThisParamAnnotationRequired:\n    \"A type annotation is required for the `this` parameter.\",\n  ThisParamBannedInConstructor:\n    \"Constructors cannot have a `this` parameter; constructors don't bind `this` like other functions.\",\n  ThisParamMayNotBeOptional: \"The `this` parameter cannot be optional.\",\n  ThisParamMustBeFirst:\n    \"The `this` parameter must be the first function parameter.\",\n  ThisParamNoDefault: \"The `this` parameter may not have a default value.\",\n  TypeBeforeInitializer:\n    \"Type annotations must come before default assignments, e.g. instead of `age = 25: number` use `age: number = 25`.\",\n  TypeCastInPattern:\n    \"The type cast expression is expected to be wrapped with parenthesis.\",\n  UnexpectedExplicitInexactInObject:\n    \"Explicit inexact syntax must appear at the end of an inexact object.\",\n  UnexpectedReservedType: ({ reservedType }: { reservedType: string }) =>\n    `Unexpected reserved type ${reservedType}.`,\n  UnexpectedReservedUnderscore:\n    \"`_` is only allowed as a type argument to call or new.\",\n  UnexpectedSpaceBetweenModuloChecks:\n    \"Spaces between `%` and `checks` are not allowed here.\",\n  UnexpectedSpreadType:\n    \"Spread operator cannot appear in class or interface definitions.\",\n  UnexpectedSubtractionOperand:\n    'Unexpected token, expected \"number\" or \"bigint\".',\n  UnexpectedTokenAfterTypeParameter:\n    \"Expected an arrow function after this type parameter declaration.\",\n  UnexpectedTypeParameterBeforeAsyncArrowFunction:\n    \"Type parameters must come after the async keyword, e.g. instead of `<T> async () => {}`, use `async <T>() => {}`.\",\n  UnsupportedDeclareExportKind: ({\n    unsupportedExportKind,\n    suggestion,\n  }: {\n    unsupportedExportKind: string;\n    suggestion: string;\n  }) =>\n    `\\`declare export ${unsupportedExportKind}\\` is not supported. Use \\`${suggestion}\\` instead.`,\n  UnsupportedStatementInDeclareModule:\n    \"Only declares and type imports are allowed inside declare module.\",\n  UnterminatedFlowComment: \"Unterminated flow-comment.\",\n});\n/* eslint-disable sort-keys */\n\nfunction isEsModuleType(bodyElement: N.Node): boolean {\n  return (\n    bodyElement.type === \"DeclareExportAllDeclaration\" ||\n    (bodyElement.type === \"DeclareExportDeclaration\" &&\n      (!bodyElement.declaration ||\n        (bodyElement.declaration.type !== \"TypeAlias\" &&\n          bodyElement.declaration.type !== \"InterfaceDeclaration\")))\n  );\n}\n\nfunction hasTypeImportKind(node: N.Node): boolean {\n  return node.importKind === \"type\" || node.importKind === \"typeof\";\n}\n\nconst exportSuggestions = {\n  const: \"declare export var\",\n  let: \"declare export var\",\n  type: \"export type\",\n  interface: \"export interface\",\n};\n\n// Like Array#filter, but returns a tuple [ acceptedElements, discardedElements ]\nfunction partition<T>(\n  list: T[],\n  test: (c: T, b: number, a: T[]) => boolean | undefined | null,\n): [T[], T[]] {\n  const list1: T[] = [];\n  const list2: T[] = [];\n  for (let i = 0; i < list.length; i++) {\n    (test(list[i], i, list) ? list1 : list2).push(list[i]);\n  }\n  return [list1, list2];\n}\n\nconst FLOW_PRAGMA_REGEX = /\\*?\\s*@((?:no)?flow)\\b/;\n\n// Flow enums types\ntype EnumExplicitType = null | \"boolean\" | \"number\" | \"string\" | \"symbol\";\n\ntype EnumContext = {\n  enumName: string;\n  explicitType: EnumExplicitType;\n  memberName: string;\n};\n\ntype EnumMemberInit =\n  | {\n      type: \"number\";\n      loc: Position;\n      value: N.Node;\n    }\n  | {\n      type: \"string\";\n      loc: Position;\n      value: N.Node;\n    }\n  | {\n      type: \"boolean\";\n      loc: Position;\n      value: N.Node;\n    }\n  | {\n      type: \"invalid\";\n      loc: Position;\n    }\n  | {\n      type: \"none\";\n      loc: Position;\n    };\n\nexport default (superClass: typeof Parser) =>\n  class FlowParserMixin extends superClass implements Parser {\n    // The value of the @flow/@noflow pragma. Initially undefined, transitions\n    // to \"@flow\" or \"@noflow\" if we see a pragma. Transitions to null if we are\n    // past the initial comment.\n    flowPragma: void | null | \"flow\" | \"noflow\" = undefined;\n\n    getScopeHandler(): {\n      new (...args: any): FlowScopeHandler;\n    } {\n      return FlowScopeHandler;\n    }\n\n    shouldParseTypes(): boolean {\n      return this.getPluginOption(\"flow\", \"all\") || this.flowPragma === \"flow\";\n    }\n\n    shouldParseEnums(): boolean {\n      return !!this.getPluginOption(\"flow\", \"enums\");\n    }\n\n    finishToken(type: TokenType, val: any): void {\n      if (\n        type !== tt.string &&\n        type !== tt.semi &&\n        type !== tt.interpreterDirective\n      ) {\n        if (this.flowPragma === undefined) {\n          this.flowPragma = null;\n        }\n      }\n      super.finishToken(type, val);\n    }\n\n    addComment(comment: N.Comment): void {\n      if (this.flowPragma === undefined) {\n        // Try to parse a flow pragma.\n        const matches = FLOW_PRAGMA_REGEX.exec(comment.value);\n        if (!matches) {\n          // do nothing\n        } else if (matches[1] === \"flow\") {\n          this.flowPragma = \"flow\";\n        } else if (matches[1] === \"noflow\") {\n          this.flowPragma = \"noflow\";\n        } else {\n          throw new Error(\"Unexpected flow pragma\");\n        }\n      }\n      super.addComment(comment);\n    }\n\n    flowParseTypeInitialiser(tok?: TokenType): N.FlowType {\n      const oldInType = this.state.inType;\n      this.state.inType = true;\n      this.expect(tok || tt.colon);\n\n      const type = this.flowParseType();\n      this.state.inType = oldInType;\n      return type;\n    }\n\n    flowParsePredicate(): N.FlowPredicate {\n      const node = this.startNode();\n      const moduloLoc = this.state.startLoc;\n      this.next(); // eat `%`\n      this.expectContextual(tt._checks);\n      // Force '%' and 'checks' to be adjacent\n      if (this.state.lastTokStart > moduloLoc.index + 1) {\n        this.raise(FlowErrors.UnexpectedSpaceBetweenModuloChecks, {\n          at: moduloLoc,\n        });\n      }\n      if (this.eat(tt.parenL)) {\n        node.value = super.parseExpression();\n        this.expect(tt.parenR);\n        return this.finishNode(node, \"DeclaredPredicate\");\n      } else {\n        return this.finishNode(node, \"InferredPredicate\");\n      }\n    }\n\n    flowParseTypeAndPredicateInitialiser(): [\n      N.FlowType | undefined | null,\n      N.FlowPredicate | undefined | null,\n    ] {\n      const oldInType = this.state.inType;\n      this.state.inType = true;\n      this.expect(tt.colon);\n      let type = null;\n      let predicate = null;\n      if (this.match(tt.modulo)) {\n        this.state.inType = oldInType;\n        predicate = this.flowParsePredicate();\n      } else {\n        type = this.flowParseType();\n        this.state.inType = oldInType;\n        if (this.match(tt.modulo)) {\n          predicate = this.flowParsePredicate();\n        }\n      }\n      return [type, predicate];\n    }\n\n    flowParseDeclareClass(\n      node: Undone<N.FlowDeclareClass>,\n    ): N.FlowDeclareClass {\n      this.next();\n      this.flowParseInterfaceish(node, /*isClass*/ true);\n      return this.finishNode(node, \"DeclareClass\");\n    }\n\n    flowParseDeclareFunction(\n      node: Undone<N.FlowDeclareFunction>,\n    ): N.FlowDeclareFunction {\n      this.next();\n\n      const id = (node.id = this.parseIdentifier());\n\n      const typeNode = this.startNode();\n      const typeContainer = this.startNode<N.TypeAnnotation>();\n\n      if (this.match(tt.lt)) {\n        typeNode.typeParameters = this.flowParseTypeParameterDeclaration();\n      } else {\n        typeNode.typeParameters = null;\n      }\n\n      this.expect(tt.parenL);\n      const tmp = this.flowParseFunctionTypeParams();\n      typeNode.params = tmp.params;\n      typeNode.rest = tmp.rest;\n      typeNode.this = tmp._this;\n      this.expect(tt.parenR);\n\n      [typeNode.returnType, node.predicate] =\n        this.flowParseTypeAndPredicateInitialiser();\n\n      typeContainer.typeAnnotation = this.finishNode(\n        typeNode,\n        \"FunctionTypeAnnotation\",\n      );\n\n      id.typeAnnotation = this.finishNode(typeContainer, \"TypeAnnotation\");\n\n      this.resetEndLocation(id);\n      this.semicolon();\n\n      this.scope.declareName(\n        node.id.name,\n        BIND_FLOW_DECLARE_FN,\n        node.id.loc.start,\n      );\n\n      return this.finishNode(node, \"DeclareFunction\");\n    }\n\n    flowParseDeclare(\n      node: Undone<N.FlowDeclare>,\n      insideModule?: boolean,\n    ): N.FlowDeclare {\n      if (this.match(tt._class)) {\n        return this.flowParseDeclareClass(node);\n      } else if (this.match(tt._function)) {\n        return this.flowParseDeclareFunction(node);\n      } else if (this.match(tt._var)) {\n        return this.flowParseDeclareVariable(node);\n      } else if (this.eatContextual(tt._module)) {\n        if (this.match(tt.dot)) {\n          return this.flowParseDeclareModuleExports(node);\n        } else {\n          if (insideModule) {\n            this.raise(FlowErrors.NestedDeclareModule, {\n              at: this.state.lastTokStartLoc,\n            });\n          }\n          return this.flowParseDeclareModule(node);\n        }\n      } else if (this.isContextual(tt._type)) {\n        return this.flowParseDeclareTypeAlias(node);\n      } else if (this.isContextual(tt._opaque)) {\n        return this.flowParseDeclareOpaqueType(node);\n      } else if (this.isContextual(tt._interface)) {\n        return this.flowParseDeclareInterface(node);\n      } else if (this.match(tt._export)) {\n        return this.flowParseDeclareExportDeclaration(node, insideModule);\n      } else {\n        this.unexpected();\n      }\n    }\n\n    flowParseDeclareVariable(\n      node: Undone<N.FlowDeclareVariable>,\n    ): N.FlowDeclareVariable {\n      this.next();\n      node.id = this.flowParseTypeAnnotatableIdentifier(\n        /*allowPrimitiveOverride*/ true,\n      );\n      this.scope.declareName(node.id.name, BIND_VAR, node.id.loc.start);\n      this.semicolon();\n      return this.finishNode(node, \"DeclareVariable\");\n    }\n\n    flowParseDeclareModule(\n      node: Undone<N.FlowDeclareModule>,\n    ): N.FlowDeclareModule {\n      this.scope.enter(SCOPE_OTHER);\n\n      if (this.match(tt.string)) {\n        node.id = super.parseExprAtom();\n      } else {\n        node.id = this.parseIdentifier();\n      }\n\n      const bodyNode = (node.body = this.startNode());\n      // @ts-expect-error refine typings\n      const body = (bodyNode.body = []);\n      this.expect(tt.braceL);\n      while (!this.match(tt.braceR)) {\n        let bodyNode = this.startNode<N.ImportDeclaration>();\n\n        if (this.match(tt._import)) {\n          this.next();\n          if (!this.isContextual(tt._type) && !this.match(tt._typeof)) {\n            this.raise(FlowErrors.InvalidNonTypeImportInDeclareModule, {\n              at: this.state.lastTokStartLoc,\n            });\n          }\n          super.parseImport(bodyNode);\n        } else {\n          this.expectContextual(\n            tt._declare,\n            FlowErrors.UnsupportedStatementInDeclareModule,\n          );\n          // @ts-expect-error refine typings\n          bodyNode = this.flowParseDeclare(bodyNode, true);\n        }\n\n        body.push(bodyNode);\n      }\n\n      this.scope.exit();\n\n      this.expect(tt.braceR);\n\n      this.finishNode(bodyNode, \"BlockStatement\");\n\n      let kind: \"CommonJS\" | \"ES\" | null = null;\n      let hasModuleExport = false;\n      body.forEach(bodyElement => {\n        if (isEsModuleType(bodyElement)) {\n          if (kind === \"CommonJS\") {\n            this.raise(FlowErrors.AmbiguousDeclareModuleKind, {\n              at: bodyElement,\n            });\n          }\n          kind = \"ES\";\n        } else if (bodyElement.type === \"DeclareModuleExports\") {\n          if (hasModuleExport) {\n            this.raise(FlowErrors.DuplicateDeclareModuleExports, {\n              at: bodyElement,\n            });\n          }\n          if (kind === \"ES\") {\n            this.raise(FlowErrors.AmbiguousDeclareModuleKind, {\n              at: bodyElement,\n            });\n          }\n          kind = \"CommonJS\";\n          hasModuleExport = true;\n        }\n      });\n\n      node.kind = kind || \"CommonJS\";\n      return this.finishNode(node, \"DeclareModule\");\n    }\n\n    flowParseDeclareExportDeclaration(\n      node: Undone<N.FlowDeclareExportDeclaration>,\n      insideModule?: boolean | null,\n    ): N.FlowDeclareExportDeclaration {\n      this.expect(tt._export);\n\n      if (this.eat(tt._default)) {\n        if (this.match(tt._function) || this.match(tt._class)) {\n          // declare export default class ...\n          // declare export default function ...\n          node.declaration = this.flowParseDeclare(this.startNode());\n        } else {\n          // declare export default [type];\n          node.declaration = this.flowParseType();\n          this.semicolon();\n        }\n        node.default = true;\n\n        return this.finishNode(node, \"DeclareExportDeclaration\");\n      } else {\n        if (\n          this.match(tt._const) ||\n          this.isLet() ||\n          ((this.isContextual(tt._type) || this.isContextual(tt._interface)) &&\n            !insideModule)\n        ) {\n          const label = this.state.value as\n            | \"const\"\n            | \"let\"\n            | \"type\"\n            | \"interface\";\n          throw this.raise(FlowErrors.UnsupportedDeclareExportKind, {\n            at: this.state.startLoc,\n            unsupportedExportKind: label,\n            suggestion: exportSuggestions[label],\n          });\n        }\n\n        if (\n          this.match(tt._var) || // declare export var ...\n          this.match(tt._function) || // declare export function ...\n          this.match(tt._class) || // declare export class ...\n          this.isContextual(tt._opaque) // declare export opaque ..\n        ) {\n          node.declaration = this.flowParseDeclare(this.startNode());\n          node.default = false;\n\n          return this.finishNode(node, \"DeclareExportDeclaration\");\n        } else if (\n          this.match(tt.star) || // declare export * from ''\n          this.match(tt.braceL) || // declare export {} ...\n          this.isContextual(tt._interface) || // declare export interface ...\n          this.isContextual(tt._type) || // declare export type ...\n          this.isContextual(tt._opaque) // declare export opaque type ...\n        ) {\n          node = this.parseExport(\n            node as Undone<N.ExportNamedDeclaration | N.ExportAllDeclaration>,\n            /* decorators */ null,\n          );\n          if (node.type === \"ExportNamedDeclaration\") {\n            node.type = \"ExportDeclaration\";\n            node.default = false;\n            delete node.exportKind;\n          }\n\n          node.type = \"Declare\" + node.type;\n\n          return node as N.Node;\n        }\n      }\n\n      this.unexpected();\n    }\n\n    flowParseDeclareModuleExports(\n      node: Undone<N.FlowDeclareModuleExports>,\n    ): N.FlowDeclareModuleExports {\n      this.next();\n      this.expectContextual(tt._exports);\n      node.typeAnnotation = this.flowParseTypeAnnotation();\n      this.semicolon();\n\n      return this.finishNode(node, \"DeclareModuleExports\");\n    }\n\n    flowParseDeclareTypeAlias(\n      node: Undone<N.FlowDeclareTypeAlias>,\n    ): N.FlowDeclareTypeAlias {\n      this.next();\n      const finished = this.flowParseTypeAlias(node);\n      // Don't do finishNode as we don't want to process comments twice\n      finished.type = \"DeclareTypeAlias\";\n      return finished;\n    }\n\n    flowParseDeclareOpaqueType(\n      node: Undone<N.FlowDeclareOpaqueType>,\n    ): N.FlowDeclareOpaqueType {\n      this.next();\n      const finished = this.flowParseOpaqueType(node, true);\n      // Don't do finishNode as we don't want to process comments twice\n      finished.type = \"DeclareOpaqueType\";\n      return finished;\n    }\n\n    flowParseDeclareInterface(\n      node: Undone<N.FlowDeclareInterface>,\n    ): N.FlowDeclareInterface {\n      this.next();\n      this.flowParseInterfaceish(node, /* isClass */ false);\n      return this.finishNode(node, \"DeclareInterface\");\n    }\n\n    // Interfaces\n\n    flowParseInterfaceish(node: Undone<N.FlowDeclare>, isClass: boolean): void {\n      node.id = this.flowParseRestrictedIdentifier(\n        /* liberal */ !isClass,\n        /* declaration */ true,\n      );\n\n      this.scope.declareName(\n        node.id.name,\n        isClass ? BIND_FUNCTION : BIND_LEXICAL,\n        node.id.loc.start,\n      );\n\n      if (this.match(tt.lt)) {\n        node.typeParameters = this.flowParseTypeParameterDeclaration();\n      } else {\n        node.typeParameters = null;\n      }\n\n      node.extends = [];\n\n      if (this.eat(tt._extends)) {\n        do {\n          node.extends.push(this.flowParseInterfaceExtends());\n        } while (!isClass && this.eat(tt.comma));\n      }\n\n      if (isClass) {\n        node.implements = [];\n        node.mixins = [];\n\n        if (this.eatContextual(tt._mixins)) {\n          do {\n            node.mixins.push(this.flowParseInterfaceExtends());\n          } while (this.eat(tt.comma));\n        }\n\n        if (this.eatContextual(tt._implements)) {\n          do {\n            node.implements.push(this.flowParseInterfaceExtends());\n          } while (this.eat(tt.comma));\n        }\n      }\n\n      node.body = this.flowParseObjectType({\n        allowStatic: isClass,\n        allowExact: false,\n        allowSpread: false,\n        allowProto: isClass,\n        allowInexact: false,\n      });\n    }\n\n    flowParseInterfaceExtends(): N.FlowInterfaceExtends {\n      const node = this.startNode();\n\n      node.id = this.flowParseQualifiedTypeIdentifier();\n      if (this.match(tt.lt)) {\n        node.typeParameters = this.flowParseTypeParameterInstantiation();\n      } else {\n        node.typeParameters = null;\n      }\n\n      return this.finishNode(node, \"InterfaceExtends\");\n    }\n\n    flowParseInterface(node: Undone<N.FlowInterface>): N.FlowInterface {\n      this.flowParseInterfaceish(node, /* isClass */ false);\n      return this.finishNode(node, \"InterfaceDeclaration\");\n    }\n\n    checkNotUnderscore(word: string) {\n      if (word === \"_\") {\n        this.raise(FlowErrors.UnexpectedReservedUnderscore, {\n          at: this.state.startLoc,\n        });\n      }\n    }\n\n    checkReservedType(word: string, startLoc: Position, declaration?: boolean) {\n      if (!reservedTypes.has(word)) return;\n\n      this.raise(\n        declaration\n          ? FlowErrors.AssignReservedType\n          : FlowErrors.UnexpectedReservedType,\n        {\n          at: startLoc,\n          reservedType: word,\n        },\n      );\n    }\n\n    flowParseRestrictedIdentifier(\n      liberal?: boolean,\n      declaration?: boolean,\n    ): N.Identifier {\n      this.checkReservedType(\n        this.state.value,\n        this.state.startLoc,\n        declaration,\n      );\n      return this.parseIdentifier(liberal);\n    }\n\n    // Type aliases\n\n    flowParseTypeAlias(node: Undone<N.FlowTypeAlias>): N.FlowTypeAlias {\n      node.id = this.flowParseRestrictedIdentifier(\n        /* liberal */ false,\n        /* declaration */ true,\n      );\n      this.scope.declareName(node.id.name, BIND_LEXICAL, node.id.loc.start);\n\n      if (this.match(tt.lt)) {\n        node.typeParameters = this.flowParseTypeParameterDeclaration();\n      } else {\n        node.typeParameters = null;\n      }\n\n      node.right = this.flowParseTypeInitialiser(tt.eq);\n      this.semicolon();\n\n      return this.finishNode(node, \"TypeAlias\");\n    }\n\n    flowParseOpaqueType(\n      node: Undone<N.FlowOpaqueType>,\n      declare: boolean,\n    ): N.FlowOpaqueType {\n      this.expectContextual(tt._type);\n      node.id = this.flowParseRestrictedIdentifier(\n        /* liberal */ true,\n        /* declaration */ true,\n      );\n      this.scope.declareName(node.id.name, BIND_LEXICAL, node.id.loc.start);\n\n      if (this.match(tt.lt)) {\n        node.typeParameters = this.flowParseTypeParameterDeclaration();\n      } else {\n        node.typeParameters = null;\n      }\n\n      // Parse the supertype\n      node.supertype = null;\n      if (this.match(tt.colon)) {\n        node.supertype = this.flowParseTypeInitialiser(tt.colon);\n      }\n\n      node.impltype = null;\n      if (!declare) {\n        node.impltype = this.flowParseTypeInitialiser(tt.eq);\n      }\n      this.semicolon();\n\n      return this.finishNode(node, \"OpaqueType\");\n    }\n\n    // Type annotations\n\n    flowParseTypeParameter(requireDefault: boolean = false): N.TypeParameter {\n      const nodeStartLoc = this.state.startLoc;\n\n      const node = this.startNode<N.TypeParameter>();\n\n      const variance = this.flowParseVariance();\n\n      const ident = this.flowParseTypeAnnotatableIdentifier();\n      node.name = ident.name;\n      // @ts-expect-error migrate to Babel types\n      node.variance = variance;\n      // @ts-expect-error migrate to Babel types\n      node.bound = ident.typeAnnotation;\n\n      if (this.match(tt.eq)) {\n        this.eat(tt.eq);\n        // @ts-expect-error migrate to Babel types\n        node.default = this.flowParseType();\n      } else {\n        if (requireDefault) {\n          this.raise(FlowErrors.MissingTypeParamDefault, { at: nodeStartLoc });\n        }\n      }\n\n      return this.finishNode(node, \"TypeParameter\");\n    }\n\n    flowParseTypeParameterDeclaration(): N.TypeParameterDeclaration {\n      const oldInType = this.state.inType;\n      const node = this.startNode<N.TypeParameterDeclaration>();\n      node.params = [];\n\n      this.state.inType = true;\n\n      // istanbul ignore else: this condition is already checked at all call sites\n      if (this.match(tt.lt) || this.match(tt.jsxTagStart)) {\n        this.next();\n      } else {\n        this.unexpected();\n      }\n\n      let defaultRequired = false;\n\n      do {\n        const typeParameter = this.flowParseTypeParameter(defaultRequired);\n\n        node.params.push(typeParameter);\n\n        if (typeParameter.default) {\n          defaultRequired = true;\n        }\n\n        if (!this.match(tt.gt)) {\n          this.expect(tt.comma);\n        }\n      } while (!this.match(tt.gt));\n      this.expect(tt.gt);\n\n      this.state.inType = oldInType;\n\n      return this.finishNode(node, \"TypeParameterDeclaration\");\n    }\n\n    flowParseTypeParameterInstantiation(): N.TypeParameterInstantiation {\n      const node = this.startNode<N.TypeParameterInstantiation>();\n      const oldInType = this.state.inType;\n      node.params = [];\n\n      this.state.inType = true;\n\n      this.expect(tt.lt);\n      const oldNoAnonFunctionType = this.state.noAnonFunctionType;\n      this.state.noAnonFunctionType = false;\n      while (!this.match(tt.gt)) {\n        node.params.push(this.flowParseType());\n        if (!this.match(tt.gt)) {\n          this.expect(tt.comma);\n        }\n      }\n      this.state.noAnonFunctionType = oldNoAnonFunctionType;\n      this.expect(tt.gt);\n\n      this.state.inType = oldInType;\n\n      return this.finishNode(node, \"TypeParameterInstantiation\");\n    }\n\n    flowParseTypeParameterInstantiationCallOrNew(): N.TypeParameterInstantiation {\n      const node = this.startNode<N.TypeParameterInstantiation>();\n      const oldInType = this.state.inType;\n      node.params = [];\n\n      this.state.inType = true;\n\n      this.expect(tt.lt);\n      while (!this.match(tt.gt)) {\n        node.params.push(this.flowParseTypeOrImplicitInstantiation());\n        if (!this.match(tt.gt)) {\n          this.expect(tt.comma);\n        }\n      }\n      this.expect(tt.gt);\n\n      this.state.inType = oldInType;\n\n      return this.finishNode(node, \"TypeParameterInstantiation\");\n    }\n\n    flowParseInterfaceType(): N.FlowInterfaceType {\n      const node = this.startNode<N.FlowInterfaceType>();\n      this.expectContextual(tt._interface);\n\n      node.extends = [];\n      if (this.eat(tt._extends)) {\n        do {\n          node.extends.push(this.flowParseInterfaceExtends());\n        } while (this.eat(tt.comma));\n      }\n\n      node.body = this.flowParseObjectType({\n        allowStatic: false,\n        allowExact: false,\n        allowSpread: false,\n        allowProto: false,\n        allowInexact: false,\n      });\n\n      return this.finishNode(node, \"InterfaceTypeAnnotation\");\n    }\n\n    flowParseObjectPropertyKey(): N.Expression {\n      return this.match(tt.num) || this.match(tt.string)\n        ? super.parseExprAtom()\n        : this.parseIdentifier(true);\n    }\n\n    flowParseObjectTypeIndexer(\n      node: Undone<N.FlowObjectTypeIndexer>,\n      isStatic: boolean,\n      variance?: N.FlowVariance | null,\n    ): N.FlowObjectTypeIndexer {\n      node.static = isStatic;\n\n      // Note: bracketL has already been consumed\n      if (this.lookahead().type === tt.colon) {\n        node.id = this.flowParseObjectPropertyKey();\n        node.key = this.flowParseTypeInitialiser();\n      } else {\n        node.id = null;\n        node.key = this.flowParseType();\n      }\n      this.expect(tt.bracketR);\n      node.value = this.flowParseTypeInitialiser();\n      node.variance = variance;\n\n      return this.finishNode(node, \"ObjectTypeIndexer\");\n    }\n\n    flowParseObjectTypeInternalSlot(\n      node: Undone<N.FlowObjectTypeInternalSlot>,\n      isStatic: boolean,\n    ): N.FlowObjectTypeInternalSlot {\n      node.static = isStatic;\n      // Note: both bracketL have already been consumed\n      node.id = this.flowParseObjectPropertyKey();\n      this.expect(tt.bracketR);\n      this.expect(tt.bracketR);\n      if (this.match(tt.lt) || this.match(tt.parenL)) {\n        node.method = true;\n        node.optional = false;\n        node.value = this.flowParseObjectTypeMethodish(\n          this.startNodeAt(node.loc.start),\n        );\n      } else {\n        node.method = false;\n        if (this.eat(tt.question)) {\n          node.optional = true;\n        }\n        node.value = this.flowParseTypeInitialiser();\n      }\n      return this.finishNode(node, \"ObjectTypeInternalSlot\");\n    }\n\n    flowParseObjectTypeMethodish(\n      node: Undone<N.FlowFunctionTypeAnnotation>,\n    ): N.FlowFunctionTypeAnnotation {\n      node.params = [];\n      node.rest = null;\n      node.typeParameters = null;\n      node.this = null;\n\n      if (this.match(tt.lt)) {\n        node.typeParameters = this.flowParseTypeParameterDeclaration();\n      }\n\n      this.expect(tt.parenL);\n      if (this.match(tt._this)) {\n        node.this = this.flowParseFunctionTypeParam(/* first */ true);\n        // match Flow parser behavior\n        node.this.name = null;\n        if (!this.match(tt.parenR)) {\n          this.expect(tt.comma);\n        }\n      }\n      while (!this.match(tt.parenR) && !this.match(tt.ellipsis)) {\n        node.params.push(this.flowParseFunctionTypeParam(false));\n        if (!this.match(tt.parenR)) {\n          this.expect(tt.comma);\n        }\n      }\n\n      if (this.eat(tt.ellipsis)) {\n        node.rest = this.flowParseFunctionTypeParam(false);\n      }\n      this.expect(tt.parenR);\n      node.returnType = this.flowParseTypeInitialiser();\n\n      return this.finishNode(node, \"FunctionTypeAnnotation\");\n    }\n\n    flowParseObjectTypeCallProperty(\n      node: Undone<N.FlowObjectTypeCallProperty>,\n      isStatic: boolean,\n    ): N.FlowObjectTypeCallProperty {\n      const valueNode = this.startNode();\n      node.static = isStatic;\n      node.value = this.flowParseObjectTypeMethodish(valueNode);\n      return this.finishNode(node, \"ObjectTypeCallProperty\");\n    }\n\n    flowParseObjectType({\n      allowStatic,\n      allowExact,\n      allowSpread,\n      allowProto,\n      allowInexact,\n    }: {\n      allowStatic: boolean;\n      allowExact: boolean;\n      allowSpread: boolean;\n      allowProto: boolean;\n      allowInexact: boolean;\n    }): N.FlowObjectTypeAnnotation {\n      const oldInType = this.state.inType;\n      this.state.inType = true;\n\n      const nodeStart = this.startNode();\n\n      nodeStart.callProperties = [];\n      nodeStart.properties = [];\n      nodeStart.indexers = [];\n      nodeStart.internalSlots = [];\n\n      let endDelim;\n      let exact;\n      let inexact = false;\n      if (allowExact && this.match(tt.braceBarL)) {\n        this.expect(tt.braceBarL);\n        endDelim = tt.braceBarR;\n        exact = true;\n      } else {\n        this.expect(tt.braceL);\n        endDelim = tt.braceR;\n        exact = false;\n      }\n\n      nodeStart.exact = exact;\n\n      while (!this.match(endDelim)) {\n        let isStatic = false;\n        let protoStartLoc: Position | undefined | null = null;\n        let inexactStartLoc: Position | undefined | null = null;\n        const node = this.startNode();\n\n        if (allowProto && this.isContextual(tt._proto)) {\n          const lookahead = this.lookahead();\n\n          if (lookahead.type !== tt.colon && lookahead.type !== tt.question) {\n            this.next();\n            protoStartLoc = this.state.startLoc;\n            allowStatic = false;\n          }\n        }\n\n        if (allowStatic && this.isContextual(tt._static)) {\n          const lookahead = this.lookahead();\n\n          // static is a valid identifier name\n          if (lookahead.type !== tt.colon && lookahead.type !== tt.question) {\n            this.next();\n            isStatic = true;\n          }\n        }\n\n        const variance = this.flowParseVariance();\n\n        if (this.eat(tt.bracketL)) {\n          if (protoStartLoc != null) {\n            this.unexpected(protoStartLoc);\n          }\n          if (this.eat(tt.bracketL)) {\n            if (variance) {\n              this.unexpected(variance.loc.start);\n            }\n            nodeStart.internalSlots.push(\n              this.flowParseObjectTypeInternalSlot(node, isStatic),\n            );\n          } else {\n            nodeStart.indexers.push(\n              this.flowParseObjectTypeIndexer(node, isStatic, variance),\n            );\n          }\n        } else if (this.match(tt.parenL) || this.match(tt.lt)) {\n          if (protoStartLoc != null) {\n            this.unexpected(protoStartLoc);\n          }\n          if (variance) {\n            this.unexpected(variance.loc.start);\n          }\n          nodeStart.callProperties.push(\n            this.flowParseObjectTypeCallProperty(node, isStatic),\n          );\n        } else {\n          let kind = \"init\";\n\n          if (this.isContextual(tt._get) || this.isContextual(tt._set)) {\n            const lookahead = this.lookahead();\n            if (tokenIsLiteralPropertyName(lookahead.type)) {\n              kind = this.state.value;\n              this.next();\n            }\n          }\n\n          const propOrInexact = this.flowParseObjectTypeProperty(\n            node,\n            isStatic,\n            protoStartLoc,\n            variance,\n            kind,\n            allowSpread,\n            allowInexact ?? !exact,\n          );\n\n          if (propOrInexact === null) {\n            inexact = true;\n            inexactStartLoc = this.state.lastTokStartLoc;\n          } else {\n            nodeStart.properties.push(propOrInexact);\n          }\n        }\n\n        this.flowObjectTypeSemicolon();\n\n        if (\n          inexactStartLoc &&\n          !this.match(tt.braceR) &&\n          !this.match(tt.braceBarR)\n        ) {\n          this.raise(FlowErrors.UnexpectedExplicitInexactInObject, {\n            at: inexactStartLoc,\n          });\n        }\n      }\n\n      this.expect(endDelim);\n\n      /* The inexact flag should only be added on ObjectTypeAnnotations that\n       * are not the body of an interface, declare interface, or declare class.\n       * Since spreads are only allowed in object types, checking that is\n       * sufficient here.\n       */\n      if (allowSpread) {\n        nodeStart.inexact = inexact;\n      }\n\n      const out = this.finishNode(nodeStart, \"ObjectTypeAnnotation\");\n\n      this.state.inType = oldInType;\n\n      return out;\n    }\n\n    flowParseObjectTypeProperty(\n      node: Undone<N.FlowObjectTypeProperty | N.FlowObjectTypeSpreadProperty>,\n      isStatic: boolean,\n      protoStartLoc: Position | undefined | null,\n      variance: N.FlowVariance | undefined | null,\n      kind: string,\n      allowSpread: boolean,\n      allowInexact: boolean,\n    ): N.FlowObjectTypeProperty | N.FlowObjectTypeSpreadProperty | null {\n      if (this.eat(tt.ellipsis)) {\n        const isInexactToken =\n          this.match(tt.comma) ||\n          this.match(tt.semi) ||\n          this.match(tt.braceR) ||\n          this.match(tt.braceBarR);\n\n        if (isInexactToken) {\n          if (!allowSpread) {\n            this.raise(FlowErrors.InexactInsideNonObject, {\n              at: this.state.lastTokStartLoc,\n            });\n          } else if (!allowInexact) {\n            this.raise(FlowErrors.InexactInsideExact, {\n              at: this.state.lastTokStartLoc,\n            });\n          }\n          if (variance) {\n            this.raise(FlowErrors.InexactVariance, { at: variance });\n          }\n\n          return null;\n        }\n\n        if (!allowSpread) {\n          this.raise(FlowErrors.UnexpectedSpreadType, {\n            at: this.state.lastTokStartLoc,\n          });\n        }\n        if (protoStartLoc != null) {\n          this.unexpected(protoStartLoc);\n        }\n        if (variance) {\n          this.raise(FlowErrors.SpreadVariance, { at: variance });\n        }\n\n        node.argument = this.flowParseType();\n        return this.finishNode(node, \"ObjectTypeSpreadProperty\");\n      } else {\n        node.key = this.flowParseObjectPropertyKey();\n        node.static = isStatic;\n        node.proto = protoStartLoc != null;\n        node.kind = kind;\n\n        let optional = false;\n        if (this.match(tt.lt) || this.match(tt.parenL)) {\n          // This is a method property\n          node.method = true;\n\n          if (protoStartLoc != null) {\n            this.unexpected(protoStartLoc);\n          }\n          if (variance) {\n            this.unexpected(variance.loc.start);\n          }\n\n          node.value = this.flowParseObjectTypeMethodish(\n            this.startNodeAt(node.loc.start),\n          );\n          if (kind === \"get\" || kind === \"set\") {\n            this.flowCheckGetterSetterParams(node);\n          }\n          /** Declared classes/interfaces do not allow spread */\n          if (\n            !allowSpread &&\n            node.key.name === \"constructor\" &&\n            node.value.this\n          ) {\n            this.raise(FlowErrors.ThisParamBannedInConstructor, {\n              at: node.value.this,\n            });\n          }\n        } else {\n          if (kind !== \"init\") this.unexpected();\n\n          node.method = false;\n\n          if (this.eat(tt.question)) {\n            optional = true;\n          }\n          node.value = this.flowParseTypeInitialiser();\n          node.variance = variance;\n        }\n\n        node.optional = optional;\n\n        return this.finishNode(node, \"ObjectTypeProperty\");\n      }\n    }\n\n    // This is similar to checkGetterSetterParams, but as\n    // @babel/parser uses non estree properties we cannot reuse it here\n    flowCheckGetterSetterParams(\n      property: Undone<\n        N.FlowObjectTypeProperty | N.FlowObjectTypeSpreadProperty\n      >,\n    ): void {\n      const paramCount = property.kind === \"get\" ? 0 : 1;\n      const length =\n        property.value.params.length + (property.value.rest ? 1 : 0);\n\n      if (property.value.this) {\n        this.raise(\n          property.kind === \"get\"\n            ? FlowErrors.GetterMayNotHaveThisParam\n            : FlowErrors.SetterMayNotHaveThisParam,\n          { at: property.value.this },\n        );\n      }\n\n      if (length !== paramCount) {\n        this.raise(\n          property.kind === \"get\"\n            ? Errors.BadGetterArity\n            : Errors.BadSetterArity,\n          { at: property },\n        );\n      }\n\n      if (property.kind === \"set\" && property.value.rest) {\n        this.raise(Errors.BadSetterRestParameter, { at: property });\n      }\n    }\n\n    flowObjectTypeSemicolon(): void {\n      if (\n        !this.eat(tt.semi) &&\n        !this.eat(tt.comma) &&\n        !this.match(tt.braceR) &&\n        !this.match(tt.braceBarR)\n      ) {\n        this.unexpected();\n      }\n    }\n\n    flowParseQualifiedTypeIdentifier(\n      startLoc?: Position,\n      id?: N.Identifier,\n    ): N.FlowQualifiedTypeIdentifier {\n      startLoc ??= this.state.startLoc;\n      let node: N.Identifier | N.FlowQualifiedTypeIdentifier =\n        id || this.flowParseRestrictedIdentifier(true);\n\n      while (this.eat(tt.dot)) {\n        const node2 = this.startNodeAt<N.FlowQualifiedTypeIdentifier>(startLoc);\n        node2.qualification = node;\n        node2.id = this.flowParseRestrictedIdentifier(true);\n        node = this.finishNode(node2, \"QualifiedTypeIdentifier\");\n      }\n\n      return node;\n    }\n\n    flowParseGenericType(\n      startLoc: Position,\n      id: N.Identifier,\n    ): N.FlowGenericTypeAnnotation {\n      const node = this.startNodeAt(startLoc);\n\n      node.typeParameters = null;\n      node.id = this.flowParseQualifiedTypeIdentifier(startLoc, id);\n\n      if (this.match(tt.lt)) {\n        node.typeParameters = this.flowParseTypeParameterInstantiation();\n      }\n\n      return this.finishNode(node, \"GenericTypeAnnotation\");\n    }\n\n    flowParseTypeofType(): N.FlowTypeofTypeAnnotation {\n      const node = this.startNode();\n      this.expect(tt._typeof);\n      node.argument = this.flowParsePrimaryType();\n      return this.finishNode(node, \"TypeofTypeAnnotation\");\n    }\n\n    flowParseTupleType(): N.FlowTupleTypeAnnotation {\n      const node = this.startNode();\n      node.types = [];\n      this.expect(tt.bracketL);\n      // We allow trailing commas\n      while (this.state.pos < this.length && !this.match(tt.bracketR)) {\n        node.types.push(this.flowParseType());\n        if (this.match(tt.bracketR)) break;\n        this.expect(tt.comma);\n      }\n      this.expect(tt.bracketR);\n      return this.finishNode(node, \"TupleTypeAnnotation\");\n    }\n\n    flowParseFunctionTypeParam(first: boolean): N.FlowFunctionTypeParam {\n      let name = null;\n      let optional = false;\n      let typeAnnotation = null;\n      const node = this.startNode<N.FlowFunctionTypeParam>();\n      const lh = this.lookahead();\n      const isThis = this.state.type === tt._this;\n\n      if (lh.type === tt.colon || lh.type === tt.question) {\n        if (isThis && !first) {\n          this.raise(FlowErrors.ThisParamMustBeFirst, { at: node });\n        }\n        name = this.parseIdentifier(isThis);\n        if (this.eat(tt.question)) {\n          optional = true;\n          if (isThis) {\n            this.raise(FlowErrors.ThisParamMayNotBeOptional, { at: node });\n          }\n        }\n        typeAnnotation = this.flowParseTypeInitialiser();\n      } else {\n        typeAnnotation = this.flowParseType();\n      }\n      node.name = name;\n      node.optional = optional;\n      node.typeAnnotation = typeAnnotation;\n      return this.finishNode(node, \"FunctionTypeParam\");\n    }\n\n    reinterpretTypeAsFunctionTypeParam(\n      type: N.FlowType,\n    ): N.FlowFunctionTypeParam {\n      const node = this.startNodeAt(type.loc.start);\n      node.name = null;\n      node.optional = false;\n      node.typeAnnotation = type;\n      return this.finishNode(node, \"FunctionTypeParam\");\n    }\n\n    flowParseFunctionTypeParams(params: N.FlowFunctionTypeParam[] = []): {\n      params: N.FlowFunctionTypeParam[];\n      rest: N.FlowFunctionTypeParam | undefined | null;\n      _this: N.FlowFunctionTypeParam | undefined | null;\n    } {\n      let rest: N.FlowFunctionTypeParam | undefined | null = null;\n      let _this: N.FlowFunctionTypeParam | undefined | null = null;\n      if (this.match(tt._this)) {\n        _this = this.flowParseFunctionTypeParam(/* first */ true);\n        // match Flow parser behavior\n        _this.name = null;\n        if (!this.match(tt.parenR)) {\n          this.expect(tt.comma);\n        }\n      }\n      while (!this.match(tt.parenR) && !this.match(tt.ellipsis)) {\n        params.push(this.flowParseFunctionTypeParam(false));\n        if (!this.match(tt.parenR)) {\n          this.expect(tt.comma);\n        }\n      }\n      if (this.eat(tt.ellipsis)) {\n        rest = this.flowParseFunctionTypeParam(false);\n      }\n      return { params, rest, _this };\n    }\n\n    flowIdentToTypeAnnotation(\n      startLoc: Position,\n      node: Undone<N.FlowTypeAnnotation>,\n      id: N.Identifier,\n    ): N.FlowTypeAnnotation {\n      switch (id.name) {\n        case \"any\":\n          return this.finishNode(node, \"AnyTypeAnnotation\");\n\n        case \"bool\":\n        case \"boolean\":\n          return this.finishNode(node, \"BooleanTypeAnnotation\");\n\n        case \"mixed\":\n          return this.finishNode(node, \"MixedTypeAnnotation\");\n\n        case \"empty\":\n          return this.finishNode(node, \"EmptyTypeAnnotation\");\n\n        case \"number\":\n          return this.finishNode(node, \"NumberTypeAnnotation\");\n\n        case \"string\":\n          return this.finishNode(node, \"StringTypeAnnotation\");\n\n        case \"symbol\":\n          return this.finishNode(node, \"SymbolTypeAnnotation\");\n\n        default:\n          this.checkNotUnderscore(id.name);\n          return this.flowParseGenericType(startLoc, id);\n      }\n    }\n\n    // The parsing of types roughly parallels the parsing of expressions, and\n    // primary types are kind of like primary expressions...they're the\n    // primitives with which other types are constructed.\n    flowParsePrimaryType(): N.FlowTypeAnnotation {\n      const startLoc = this.state.startLoc;\n      const node = this.startNode();\n      let tmp;\n      let type;\n      let isGroupedType = false;\n      const oldNoAnonFunctionType = this.state.noAnonFunctionType;\n\n      switch (this.state.type) {\n        case tt.braceL:\n          return this.flowParseObjectType({\n            allowStatic: false,\n            allowExact: false,\n            allowSpread: true,\n            allowProto: false,\n            allowInexact: true,\n          });\n\n        case tt.braceBarL:\n          return this.flowParseObjectType({\n            allowStatic: false,\n            allowExact: true,\n            allowSpread: true,\n            allowProto: false,\n            allowInexact: false,\n          });\n\n        case tt.bracketL:\n          this.state.noAnonFunctionType = false;\n          type = this.flowParseTupleType();\n          this.state.noAnonFunctionType = oldNoAnonFunctionType;\n          return type;\n\n        case tt.lt:\n          node.typeParameters = this.flowParseTypeParameterDeclaration();\n          this.expect(tt.parenL);\n          tmp = this.flowParseFunctionTypeParams();\n          node.params = tmp.params;\n          node.rest = tmp.rest;\n          node.this = tmp._this;\n          this.expect(tt.parenR);\n\n          this.expect(tt.arrow);\n\n          node.returnType = this.flowParseType();\n\n          return this.finishNode(node, \"FunctionTypeAnnotation\");\n\n        case tt.parenL:\n          this.next();\n\n          // Check to see if this is actually a grouped type\n          if (!this.match(tt.parenR) && !this.match(tt.ellipsis)) {\n            if (tokenIsIdentifier(this.state.type) || this.match(tt._this)) {\n              const token = this.lookahead().type;\n              isGroupedType = token !== tt.question && token !== tt.colon;\n            } else {\n              isGroupedType = true;\n            }\n          }\n\n          if (isGroupedType) {\n            this.state.noAnonFunctionType = false;\n            type = this.flowParseType();\n            this.state.noAnonFunctionType = oldNoAnonFunctionType;\n\n            // A `,` or a `) =>` means this is an anonymous function type\n            if (\n              this.state.noAnonFunctionType ||\n              !(\n                this.match(tt.comma) ||\n                (this.match(tt.parenR) && this.lookahead().type === tt.arrow)\n              )\n            ) {\n              this.expect(tt.parenR);\n              return type;\n            } else {\n              // Eat a comma if there is one\n              this.eat(tt.comma);\n            }\n          }\n\n          if (type) {\n            tmp = this.flowParseFunctionTypeParams([\n              this.reinterpretTypeAsFunctionTypeParam(type),\n            ]);\n          } else {\n            tmp = this.flowParseFunctionTypeParams();\n          }\n\n          node.params = tmp.params;\n          node.rest = tmp.rest;\n          node.this = tmp._this;\n\n          this.expect(tt.parenR);\n\n          this.expect(tt.arrow);\n\n          node.returnType = this.flowParseType();\n\n          node.typeParameters = null;\n\n          return this.finishNode(node, \"FunctionTypeAnnotation\");\n\n        case tt.string:\n          return this.parseLiteral<N.StringLiteralTypeAnnotation>(\n            this.state.value,\n            \"StringLiteralTypeAnnotation\",\n          );\n\n        case tt._true:\n        case tt._false:\n          node.value = this.match(tt._true);\n          this.next();\n          return this.finishNode(\n            node as Undone<N.BooleanLiteralTypeAnnotation>,\n            \"BooleanLiteralTypeAnnotation\",\n          );\n\n        case tt.plusMin:\n          if (this.state.value === \"-\") {\n            this.next();\n            if (this.match(tt.num)) {\n              return this.parseLiteralAtNode<N.NumberLiteralTypeAnnotation>(\n                -this.state.value,\n                \"NumberLiteralTypeAnnotation\",\n                node,\n              );\n            }\n\n            if (this.match(tt.bigint)) {\n              return this.parseLiteralAtNode<N.BigIntLiteralTypeAnnotation>(\n                -this.state.value,\n                \"BigIntLiteralTypeAnnotation\",\n                node,\n              );\n            }\n\n            throw this.raise(FlowErrors.UnexpectedSubtractionOperand, {\n              at: this.state.startLoc,\n            });\n          }\n          this.unexpected();\n          return;\n        case tt.num:\n          return this.parseLiteral(\n            this.state.value,\n            \"NumberLiteralTypeAnnotation\",\n          );\n\n        case tt.bigint:\n          return this.parseLiteral(\n            this.state.value,\n            \"BigIntLiteralTypeAnnotation\",\n          );\n\n        case tt._void:\n          this.next();\n          return this.finishNode(node, \"VoidTypeAnnotation\");\n\n        case tt._null:\n          this.next();\n          return this.finishNode(node, \"NullLiteralTypeAnnotation\");\n\n        case tt._this:\n          this.next();\n          return this.finishNode(node, \"ThisTypeAnnotation\");\n\n        case tt.star:\n          this.next();\n          return this.finishNode(node, \"ExistsTypeAnnotation\");\n\n        case tt._typeof:\n          return this.flowParseTypeofType();\n\n        default:\n          if (tokenIsKeyword(this.state.type)) {\n            const label = tokenLabelName(this.state.type);\n            this.next();\n            return super.createIdentifier(node as Undone<N.Identifier>, label);\n          } else if (tokenIsIdentifier(this.state.type)) {\n            if (this.isContextual(tt._interface)) {\n              return this.flowParseInterfaceType();\n            }\n\n            return this.flowIdentToTypeAnnotation(\n              startLoc,\n              node,\n              this.parseIdentifier(),\n            );\n          }\n      }\n\n      this.unexpected();\n    }\n\n    flowParsePostfixType(): N.FlowTypeAnnotation {\n      const startLoc = this.state.startLoc;\n      let type = this.flowParsePrimaryType();\n      let seenOptionalIndexedAccess = false;\n      while (\n        (this.match(tt.bracketL) || this.match(tt.questionDot)) &&\n        !this.canInsertSemicolon()\n      ) {\n        const node = this.startNodeAt(startLoc);\n        const optional = this.eat(tt.questionDot);\n        seenOptionalIndexedAccess = seenOptionalIndexedAccess || optional;\n        this.expect(tt.bracketL);\n        if (!optional && this.match(tt.bracketR)) {\n          node.elementType = type;\n          this.next(); // eat `]`\n          type = this.finishNode(node, \"ArrayTypeAnnotation\");\n        } else {\n          node.objectType = type;\n          node.indexType = this.flowParseType();\n          this.expect(tt.bracketR);\n          if (seenOptionalIndexedAccess) {\n            node.optional = optional;\n            type = this.finishNode<N.FlowOptionalIndexedAccessType>(\n              // @ts-expect-error todo(flow->ts)\n              node,\n              \"OptionalIndexedAccessType\",\n            );\n          } else {\n            type = this.finishNode<N.FlowIndexedAccessType>(\n              // @ts-expect-error todo(flow->ts)\n              node,\n              \"IndexedAccessType\",\n            );\n          }\n        }\n      }\n      return type;\n    }\n\n    flowParsePrefixType(): N.FlowTypeAnnotation {\n      const node = this.startNode();\n      if (this.eat(tt.question)) {\n        node.typeAnnotation = this.flowParsePrefixType();\n        return this.finishNode(node, \"NullableTypeAnnotation\");\n      } else {\n        return this.flowParsePostfixType();\n      }\n    }\n\n    flowParseAnonFunctionWithoutParens(): N.FlowTypeAnnotation {\n      const param = this.flowParsePrefixType();\n      if (!this.state.noAnonFunctionType && this.eat(tt.arrow)) {\n        // TODO: This should be a type error. Passing in a SourceLocation, and it expects a Position.\n        const node = this.startNodeAt(param.loc.start);\n        node.params = [this.reinterpretTypeAsFunctionTypeParam(param)];\n        node.rest = null;\n        node.this = null;\n        node.returnType = this.flowParseType();\n        node.typeParameters = null;\n        return this.finishNode(node, \"FunctionTypeAnnotation\");\n      }\n      return param;\n    }\n\n    flowParseIntersectionType(): N.FlowTypeAnnotation {\n      const node = this.startNode();\n      this.eat(tt.bitwiseAND);\n      const type = this.flowParseAnonFunctionWithoutParens();\n      node.types = [type];\n      while (this.eat(tt.bitwiseAND)) {\n        node.types.push(this.flowParseAnonFunctionWithoutParens());\n      }\n      return node.types.length === 1\n        ? type\n        : this.finishNode(node, \"IntersectionTypeAnnotation\");\n    }\n\n    flowParseUnionType(): N.FlowTypeAnnotation {\n      const node = this.startNode();\n      this.eat(tt.bitwiseOR);\n      const type = this.flowParseIntersectionType();\n      node.types = [type];\n      while (this.eat(tt.bitwiseOR)) {\n        node.types.push(this.flowParseIntersectionType());\n      }\n      return node.types.length === 1\n        ? type\n        : this.finishNode(node, \"UnionTypeAnnotation\");\n    }\n\n    flowParseType(): N.FlowTypeAnnotation {\n      const oldInType = this.state.inType;\n      this.state.inType = true;\n      const type = this.flowParseUnionType();\n      this.state.inType = oldInType;\n      return type;\n    }\n\n    flowParseTypeOrImplicitInstantiation(): N.FlowTypeAnnotation {\n      if (this.state.type === tt.name && this.state.value === \"_\") {\n        const startLoc = this.state.startLoc;\n        const node = this.parseIdentifier();\n        return this.flowParseGenericType(startLoc, node);\n      } else {\n        return this.flowParseType();\n      }\n    }\n\n    flowParseTypeAnnotation(): N.FlowTypeAnnotation {\n      const node = this.startNode<N.FlowTypeAnnotation>();\n      node.typeAnnotation = this.flowParseTypeInitialiser();\n      return this.finishNode(node, \"TypeAnnotation\");\n    }\n\n    flowParseTypeAnnotatableIdentifier(\n      allowPrimitiveOverride?: boolean,\n    ): N.Identifier {\n      const ident = allowPrimitiveOverride\n        ? this.parseIdentifier()\n        : this.flowParseRestrictedIdentifier();\n      if (this.match(tt.colon)) {\n        // @ts-expect-error: refine typings\n        ident.typeAnnotation = this.flowParseTypeAnnotation();\n        this.resetEndLocation(ident);\n      }\n      return ident;\n    }\n\n    typeCastToParameter(node: N.Node): N.Node {\n      node.expression.typeAnnotation = node.typeAnnotation;\n\n      this.resetEndLocation(node.expression, node.typeAnnotation.loc.end);\n\n      return node.expression;\n    }\n\n    flowParseVariance(): N.FlowVariance | undefined | null {\n      let variance = null;\n      if (this.match(tt.plusMin)) {\n        variance = this.startNode<N.FlowVariance>();\n        if (this.state.value === \"+\") {\n          variance.kind = \"plus\";\n        } else {\n          variance.kind = \"minus\";\n        }\n        this.next();\n        return this.finishNode(variance, \"Variance\");\n      }\n      return variance;\n    }\n\n    // ==================================\n    // Overrides\n    // ==================================\n\n    parseFunctionBody(\n      node: N.Function,\n      allowExpressionBody?: boolean | null,\n      isMethod: boolean = false,\n    ): void {\n      if (allowExpressionBody) {\n        this.forwardNoArrowParamsConversionAt(node, () =>\n          super.parseFunctionBody(node, true, isMethod),\n        );\n        return;\n      }\n\n      super.parseFunctionBody(node, false, isMethod);\n    }\n\n    parseFunctionBodyAndFinish<\n      T extends\n        | N.Function\n        | N.TSDeclareMethod\n        | N.TSDeclareFunction\n        | N.ClassPrivateMethod,\n    >(node: Undone<T>, type: T[\"type\"], isMethod: boolean = false): T {\n      if (this.match(tt.colon)) {\n        const typeNode = this.startNode<N.TypeAnnotation>();\n\n        [\n          typeNode.typeAnnotation,\n          // @ts-expect-error predicate may not exist\n          node.predicate,\n        ] = this.flowParseTypeAndPredicateInitialiser();\n\n        node.returnType = typeNode.typeAnnotation\n          ? this.finishNode(typeNode, \"TypeAnnotation\")\n          : null;\n      }\n\n      return super.parseFunctionBodyAndFinish(node, type, isMethod);\n    }\n\n    // interfaces and enums\n    parseStatementLike(flags: ParseStatementFlag): N.Statement {\n      // strict mode handling of `interface` since it's a reserved word\n      if (this.state.strict && this.isContextual(tt._interface)) {\n        const lookahead = this.lookahead();\n        if (tokenIsKeywordOrIdentifier(lookahead.type)) {\n          const node = this.startNode<N.FlowInterface>();\n          this.next();\n          return this.flowParseInterface(node);\n        }\n      } else if (this.shouldParseEnums() && this.isContextual(tt._enum)) {\n        const node = this.startNode();\n        this.next();\n        return this.flowParseEnumDeclaration(node);\n      }\n      const stmt = super.parseStatementLike(flags);\n      // We will parse a flow pragma in any comment before the first statement.\n      if (this.flowPragma === undefined && !this.isValidDirective(stmt)) {\n        this.flowPragma = null;\n      }\n      return stmt;\n    }\n\n    // declares, interfaces and type aliases\n    parseExpressionStatement(\n      node: N.ExpressionStatement,\n      expr: N.Expression,\n      decorators: N.Decorator[] | null,\n    ): N.ExpressionStatement {\n      if (expr.type === \"Identifier\") {\n        if (expr.name === \"declare\") {\n          if (\n            this.match(tt._class) ||\n            tokenIsIdentifier(this.state.type) ||\n            this.match(tt._function) ||\n            this.match(tt._var) ||\n            this.match(tt._export)\n          ) {\n            // @ts-expect-error: refine typings\n            return this.flowParseDeclare(node);\n          }\n        } else if (tokenIsIdentifier(this.state.type)) {\n          if (expr.name === \"interface\") {\n            // @ts-expect-error: refine typings\n            return this.flowParseInterface(node);\n          } else if (expr.name === \"type\") {\n            // @ts-expect-error: refine typings\n            return this.flowParseTypeAlias(node);\n          } else if (expr.name === \"opaque\") {\n            // @ts-expect-error: refine typings\n            return this.flowParseOpaqueType(node, false);\n          }\n        }\n      }\n\n      return super.parseExpressionStatement(node, expr, decorators);\n    }\n\n    // export type\n    shouldParseExportDeclaration(): boolean {\n      const { type } = this.state;\n      if (\n        tokenIsFlowInterfaceOrTypeOrOpaque(type) ||\n        (this.shouldParseEnums() && type === tt._enum)\n      ) {\n        return !this.state.containsEsc;\n      }\n      return super.shouldParseExportDeclaration();\n    }\n\n    isExportDefaultSpecifier(): boolean {\n      const { type } = this.state;\n      if (\n        tokenIsFlowInterfaceOrTypeOrOpaque(type) ||\n        (this.shouldParseEnums() && type === tt._enum)\n      ) {\n        return this.state.containsEsc;\n      }\n\n      return super.isExportDefaultSpecifier();\n    }\n\n    parseExportDefaultExpression(): N.Expression | N.Declaration {\n      if (this.shouldParseEnums() && this.isContextual(tt._enum)) {\n        const node = this.startNode();\n        this.next();\n        return this.flowParseEnumDeclaration(node);\n      }\n      return super.parseExportDefaultExpression();\n    }\n\n    parseConditional(\n      expr: N.Expression,\n\n      startLoc: Position,\n      refExpressionErrors?: ExpressionErrors | null,\n    ): N.Expression {\n      if (!this.match(tt.question)) return expr;\n\n      if (this.state.maybeInArrowParameters) {\n        const nextCh = this.lookaheadCharCode();\n        // These tokens cannot start an expression, so if one of them follows\n        // ? then we are probably in an arrow function parameters list and we\n        // don't parse the conditional expression.\n        if (\n          nextCh === charCodes.comma || // (a?, b) => c\n          nextCh === charCodes.equalsTo || // (a? = b) => c\n          nextCh === charCodes.colon || // (a?: b) => c\n          nextCh === charCodes.rightParenthesis // (a?) => c\n        ) {\n          /*:: invariant(refExpressionErrors != null) */\n          this.setOptionalParametersError(refExpressionErrors);\n          return expr;\n        }\n      }\n\n      this.expect(tt.question);\n      const state = this.state.clone();\n      const originalNoArrowAt = this.state.noArrowAt;\n      const node = this.startNodeAt(startLoc);\n      let { consequent, failed } = this.tryParseConditionalConsequent();\n      let [valid, invalid] = this.getArrowLikeExpressions(consequent);\n\n      if (failed || invalid.length > 0) {\n        const noArrowAt = [...originalNoArrowAt];\n\n        if (invalid.length > 0) {\n          this.state = state;\n          this.state.noArrowAt = noArrowAt;\n\n          for (let i = 0; i < invalid.length; i++) {\n            noArrowAt.push(invalid[i].start);\n          }\n\n          ({ consequent, failed } = this.tryParseConditionalConsequent());\n          [valid, invalid] = this.getArrowLikeExpressions(consequent);\n        }\n\n        if (failed && valid.length > 1) {\n          // if there are two or more possible correct ways of parsing, throw an\n          // error.\n          // e.g.   Source: a ? (b): c => (d): e => f\n          //      Result 1: a ? b : (c => ((d): e => f))\n          //      Result 2: a ? ((b): c => d) : (e => f)\n          this.raise(FlowErrors.AmbiguousConditionalArrow, {\n            at: state.startLoc,\n          });\n        }\n\n        if (failed && valid.length === 1) {\n          this.state = state;\n          noArrowAt.push(valid[0].start);\n          this.state.noArrowAt = noArrowAt;\n          ({ consequent, failed } = this.tryParseConditionalConsequent());\n        }\n      }\n\n      this.getArrowLikeExpressions(consequent, true);\n\n      this.state.noArrowAt = originalNoArrowAt;\n      this.expect(tt.colon);\n\n      node.test = expr;\n      node.consequent = consequent;\n      node.alternate = this.forwardNoArrowParamsConversionAt(node, () =>\n        this.parseMaybeAssign(undefined, undefined),\n      );\n\n      return this.finishNode(node, \"ConditionalExpression\");\n    }\n\n    tryParseConditionalConsequent(): {\n      consequent: N.Expression;\n      failed: boolean;\n    } {\n      this.state.noArrowParamsConversionAt.push(this.state.start);\n\n      const consequent = this.parseMaybeAssignAllowIn();\n      const failed = !this.match(tt.colon);\n\n      this.state.noArrowParamsConversionAt.pop();\n\n      return { consequent, failed };\n    }\n\n    // Given an expression, walks through out its arrow functions whose body is\n    // an expression and through out conditional expressions. It returns every\n    // function which has been parsed with a return type but could have been\n    // parenthesized expressions.\n    // These functions are separated into two arrays: one containing the ones\n    // whose parameters can be converted to assignable lists, one containing the\n    // others.\n    getArrowLikeExpressions(\n      node: N.Expression,\n      disallowInvalid?: boolean,\n    ): [N.ArrowFunctionExpression[], N.ArrowFunctionExpression[]] {\n      const stack = [node];\n      const arrows: N.ArrowFunctionExpression[] = [];\n\n      while (stack.length !== 0) {\n        const node = stack.pop();\n        if (node.type === \"ArrowFunctionExpression\") {\n          if (node.typeParameters || !node.returnType) {\n            // This is an arrow expression without ambiguity, so check its parameters\n            // @ts-expect-error: refine typings\n            this.finishArrowValidation(node);\n          } else {\n            // @ts-expect-error: refine typings\n            arrows.push(node);\n          }\n          stack.push(node.body);\n        } else if (node.type === \"ConditionalExpression\") {\n          stack.push(node.consequent);\n          stack.push(node.alternate);\n        }\n      }\n\n      if (disallowInvalid) {\n        arrows.forEach(node => this.finishArrowValidation(node));\n        return [arrows, []];\n      }\n\n      return partition(arrows, node =>\n        node.params.every(param => this.isAssignable(param, true)),\n      );\n    }\n\n    finishArrowValidation(node: N.ArrowFunctionExpression) {\n      this.toAssignableList(\n        // node.params is Expression[] instead of $ReadOnlyArray<Pattern> because it\n        // has not been converted yet.\n        node.params as any as N.Expression[],\n        node.extra?.trailingCommaLoc,\n        /* isLHS */ false,\n      );\n      // Enter scope, as checkParams defines bindings\n      this.scope.enter(SCOPE_FUNCTION | SCOPE_ARROW);\n      // Use super's method to force the parameters to be checked\n      super.checkParams(node, false, true);\n      this.scope.exit();\n    }\n\n    forwardNoArrowParamsConversionAt<T>(\n      node: Undone<N.Node>,\n      parse: () => T,\n    ): T {\n      let result: T;\n      if (this.state.noArrowParamsConversionAt.indexOf(node.start) !== -1) {\n        this.state.noArrowParamsConversionAt.push(this.state.start);\n        result = parse();\n        this.state.noArrowParamsConversionAt.pop();\n      } else {\n        result = parse();\n      }\n\n      return result;\n    }\n\n    parseParenItem(\n      node: N.Expression,\n\n      startLoc: Position,\n    ): N.Expression {\n      node = super.parseParenItem(node, startLoc);\n      if (this.eat(tt.question)) {\n        node.optional = true;\n        // Include questionmark in location of node\n        // Don't use this.finishNode() as otherwise we might process comments twice and\n        // include already consumed parens\n        this.resetEndLocation(node);\n      }\n\n      if (this.match(tt.colon)) {\n        const typeCastNode = this.startNodeAt(startLoc);\n        typeCastNode.expression = node;\n        typeCastNode.typeAnnotation = this.flowParseTypeAnnotation();\n\n        return this.finishNode(typeCastNode, \"TypeCastExpression\");\n      }\n\n      return node;\n    }\n\n    assertModuleNodeAllowed(node: N.Node) {\n      if (\n        (node.type === \"ImportDeclaration\" &&\n          (node.importKind === \"type\" || node.importKind === \"typeof\")) ||\n        (node.type === \"ExportNamedDeclaration\" &&\n          node.exportKind === \"type\") ||\n        (node.type === \"ExportAllDeclaration\" && node.exportKind === \"type\")\n      ) {\n        // Allow Flowtype imports and exports in all conditions because\n        // Flow itself does not care about 'sourceType'.\n        return;\n      }\n\n      super.assertModuleNodeAllowed(node);\n    }\n\n    parseExportDeclaration(\n      node: N.ExportNamedDeclaration,\n    ): N.Declaration | undefined | null {\n      if (this.isContextual(tt._type)) {\n        node.exportKind = \"type\";\n\n        const declarationNode = this.startNode();\n        this.next();\n\n        if (this.match(tt.braceL)) {\n          // export type { foo, bar };\n          node.specifiers = this.parseExportSpecifiers(\n            /* isInTypeExport */ true,\n          );\n          super.parseExportFrom(node);\n          return null;\n        } else {\n          // export type Foo = Bar;\n          // @ts-expect-error: refine typings\n          return this.flowParseTypeAlias(declarationNode);\n        }\n      } else if (this.isContextual(tt._opaque)) {\n        node.exportKind = \"type\";\n\n        const declarationNode = this.startNode();\n        this.next();\n        // export opaque type Foo = Bar;\n        // @ts-expect-error: refine typings\n        return this.flowParseOpaqueType(declarationNode, false);\n      } else if (this.isContextual(tt._interface)) {\n        node.exportKind = \"type\";\n        const declarationNode = this.startNode();\n        this.next();\n        // @ts-expect-error: refine typings\n        return this.flowParseInterface(declarationNode);\n      } else if (this.shouldParseEnums() && this.isContextual(tt._enum)) {\n        node.exportKind = \"value\";\n        const declarationNode = this.startNode();\n        this.next();\n        // @ts-expect-error: refine typings\n        return this.flowParseEnumDeclaration(declarationNode);\n      } else {\n        return super.parseExportDeclaration(node);\n      }\n    }\n\n    eatExportStar(node: N.Node): boolean {\n      if (super.eatExportStar(node)) return true;\n\n      if (this.isContextual(tt._type) && this.lookahead().type === tt.star) {\n        node.exportKind = \"type\";\n        this.next();\n        this.next();\n        return true;\n      }\n\n      return false;\n    }\n\n    maybeParseExportNamespaceSpecifier(node: N.Node): boolean {\n      const { startLoc } = this.state;\n      const hasNamespace = super.maybeParseExportNamespaceSpecifier(node);\n      if (hasNamespace && node.exportKind === \"type\") {\n        this.unexpected(startLoc);\n      }\n      return hasNamespace;\n    }\n\n    parseClassId(\n      node: N.Class,\n      isStatement: boolean,\n      optionalId?: boolean | null,\n    ) {\n      super.parseClassId(node, isStatement, optionalId);\n      if (this.match(tt.lt)) {\n        node.typeParameters = this.flowParseTypeParameterDeclaration();\n      }\n    }\n\n    parseClassMember(\n      classBody: N.ClassBody,\n      member: any,\n      state: N.ParseClassMemberState,\n    ): void {\n      const { startLoc } = this.state;\n      if (this.isContextual(tt._declare)) {\n        if (super.parseClassMemberFromModifier(classBody, member)) {\n          // 'declare' is a class element name\n          return;\n        }\n\n        member.declare = true;\n      }\n\n      super.parseClassMember(classBody, member, state);\n\n      if (member.declare) {\n        if (\n          member.type !== \"ClassProperty\" &&\n          member.type !== \"ClassPrivateProperty\" &&\n          member.type !== \"PropertyDefinition\" // Used by estree plugin\n        ) {\n          this.raise(FlowErrors.DeclareClassElement, { at: startLoc });\n        } else if (member.value) {\n          this.raise(FlowErrors.DeclareClassFieldInitializer, {\n            at: member.value,\n          });\n        }\n      }\n    }\n\n    isIterator(word: string): boolean {\n      return word === \"iterator\" || word === \"asyncIterator\";\n    }\n\n    readIterator(): void {\n      const word = super.readWord1();\n      const fullWord = \"@@\" + word;\n\n      // Allow @@iterator and @@asyncIterator as a identifier only inside type\n      if (!this.isIterator(word) || !this.state.inType) {\n        this.raise(Errors.InvalidIdentifier, {\n          at: this.state.curPosition(),\n          identifierName: fullWord,\n        });\n      }\n\n      this.finishToken(tt.name, fullWord);\n    }\n\n    // ensure that inside flow types, we bypass the jsx parser plugin\n    getTokenFromCode(code: number): void {\n      const next = this.input.charCodeAt(this.state.pos + 1);\n      if (code === charCodes.leftCurlyBrace && next === charCodes.verticalBar) {\n        this.finishOp(tt.braceBarL, 2);\n      } else if (\n        this.state.inType &&\n        (code === charCodes.greaterThan || code === charCodes.lessThan)\n      ) {\n        this.finishOp(code === charCodes.greaterThan ? tt.gt : tt.lt, 1);\n      } else if (this.state.inType && code === charCodes.questionMark) {\n        if (next === charCodes.dot) {\n          this.finishOp(tt.questionDot, 2);\n        } else {\n          // allow double nullable types in Flow: ??string\n          this.finishOp(tt.question, 1);\n        }\n      } else if (\n        isIteratorStart(code, next, this.input.charCodeAt(this.state.pos + 2))\n      ) {\n        this.state.pos += 2; // eat \"@@\"\n        this.readIterator();\n      } else {\n        super.getTokenFromCode(code);\n      }\n    }\n\n    isAssignable(node: N.Node, isBinding?: boolean): boolean {\n      if (node.type === \"TypeCastExpression\") {\n        return this.isAssignable(node.expression, isBinding);\n      } else {\n        return super.isAssignable(node, isBinding);\n      }\n    }\n\n    toAssignable(node: N.Node, isLHS: boolean = false): void {\n      if (\n        !isLHS &&\n        node.type === \"AssignmentExpression\" &&\n        node.left.type === \"TypeCastExpression\"\n      ) {\n        node.left = this.typeCastToParameter(node.left);\n      }\n      super.toAssignable(node, isLHS);\n    }\n\n    // turn type casts that we found in function parameter head into type annotated params\n    toAssignableList(\n      exprList: N.Expression[],\n      trailingCommaLoc: Position | undefined | null,\n      isLHS: boolean,\n    ): void {\n      for (let i = 0; i < exprList.length; i++) {\n        const expr = exprList[i];\n        if (expr?.type === \"TypeCastExpression\") {\n          exprList[i] = this.typeCastToParameter(expr);\n        }\n      }\n      super.toAssignableList(exprList, trailingCommaLoc, isLHS);\n    }\n\n    // this is a list of nodes, from something like a call expression, we need to filter the\n    // type casts that we've found that are illegal in this context\n    toReferencedList(\n      exprList: ReadonlyArray<N.Expression | undefined | null>,\n      isParenthesizedExpr?: boolean,\n    ): ReadonlyArray<N.Expression | undefined | null> {\n      for (let i = 0; i < exprList.length; i++) {\n        const expr = exprList[i];\n        if (\n          expr &&\n          expr.type === \"TypeCastExpression\" &&\n          !expr.extra?.parenthesized &&\n          (exprList.length > 1 || !isParenthesizedExpr)\n        ) {\n          this.raise(FlowErrors.TypeCastInPattern, {\n            at: expr.typeAnnotation,\n          });\n        }\n      }\n\n      return exprList;\n    }\n\n    parseArrayLike(\n      close: TokenType,\n      canBePattern: boolean,\n      isTuple: boolean,\n      refExpressionErrors?: ExpressionErrors | null,\n    ): N.ArrayExpression | N.TupleExpression {\n      const node = super.parseArrayLike(\n        close,\n        canBePattern,\n        isTuple,\n        refExpressionErrors,\n      );\n\n      // This could be an array pattern:\n      //   ([a: string, b: string]) => {}\n      // In this case, we don't have to call toReferencedList. We will\n      // call it, if needed, when we are sure that it is a parenthesized\n      // expression by calling toReferencedListDeep.\n      if (canBePattern && !this.state.maybeInArrowParameters) {\n        this.toReferencedList(node.elements);\n      }\n\n      return node;\n    }\n\n    isValidLVal(type: string, isParenthesized: boolean, binding: BindingTypes) {\n      return (\n        type === \"TypeCastExpression\" ||\n        super.isValidLVal(type, isParenthesized, binding)\n      );\n    }\n\n    // parse class property type annotations\n    parseClassProperty(node: N.ClassProperty): N.ClassProperty {\n      if (this.match(tt.colon)) {\n        // @ts-expect-error refine typings\n        node.typeAnnotation = this.flowParseTypeAnnotation();\n      }\n      return super.parseClassProperty(node);\n    }\n\n    parseClassPrivateProperty(\n      node: N.ClassPrivateProperty,\n    ): N.ClassPrivateProperty {\n      if (this.match(tt.colon)) {\n        // @ts-expect-error refine typings\n        node.typeAnnotation = this.flowParseTypeAnnotation();\n      }\n      return super.parseClassPrivateProperty(node);\n    }\n\n    // determine whether or not we're currently in the position where a class method would appear\n    isClassMethod(): boolean {\n      return this.match(tt.lt) || super.isClassMethod();\n    }\n\n    // determine whether or not we're currently in the position where a class property would appear\n    isClassProperty(): boolean {\n      return this.match(tt.colon) || super.isClassProperty();\n    }\n\n    isNonstaticConstructor(method: N.ClassMethod | N.ClassProperty): boolean {\n      return !this.match(tt.colon) && super.isNonstaticConstructor(method);\n    }\n\n    // parse type parameters for class methods\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      if ((method as any).variance) {\n        this.unexpected((method as any).variance.loc.start);\n      }\n      delete (method as any).variance;\n      if (this.match(tt.lt)) {\n        method.typeParameters = this.flowParseTypeParameterDeclaration();\n      }\n\n      super.pushClassMethod(\n        classBody,\n        method,\n        isGenerator,\n        isAsync,\n        isConstructor,\n        allowsDirectSuper,\n      );\n\n      if (method.params && isConstructor) {\n        const params = method.params;\n        if (params.length > 0 && this.isThisParam(params[0])) {\n          this.raise(FlowErrors.ThisParamBannedInConstructor, { at: method });\n        }\n        // estree support\n      } else if (\n        // @ts-expect-error TS does not know about the face that estree can replace ClassMethod with MethodDefinition\n        method.type === \"MethodDefinition\" &&\n        isConstructor &&\n        // @ts-expect-error estree\n        method.value.params\n      ) {\n        // @ts-expect-error estree\n        const params = method.value.params;\n        if (params.length > 0 && this.isThisParam(params[0])) {\n          this.raise(FlowErrors.ThisParamBannedInConstructor, { at: method });\n        }\n      }\n    }\n\n    pushClassPrivateMethod(\n      classBody: N.ClassBody,\n      method: N.ClassPrivateMethod,\n      isGenerator: boolean,\n      isAsync: boolean,\n    ): void {\n      if ((method as any).variance) {\n        this.unexpected((method as any).variance.loc.start);\n      }\n      delete (method as any).variance;\n      if (this.match(tt.lt)) {\n        method.typeParameters = this.flowParseTypeParameterDeclaration();\n      }\n\n      super.pushClassPrivateMethod(classBody, method, isGenerator, isAsync);\n    }\n\n    // parse a the super class type parameters and implements\n    parseClassSuper(node: N.Class): void {\n      super.parseClassSuper(node);\n      if (node.superClass && this.match(tt.lt)) {\n        node.superTypeParameters = this.flowParseTypeParameterInstantiation();\n      }\n      if (this.isContextual(tt._implements)) {\n        this.next();\n        const implemented: N.FlowClassImplements[] = (node.implements = []);\n        do {\n          const node = this.startNode();\n          node.id = this.flowParseRestrictedIdentifier(/*liberal*/ true);\n          if (this.match(tt.lt)) {\n            node.typeParameters = this.flowParseTypeParameterInstantiation();\n          } else {\n            node.typeParameters = null;\n          }\n          implemented.push(this.finishNode(node, \"ClassImplements\"));\n        } while (this.eat(tt.comma));\n      }\n    }\n\n    checkGetterSetterParams(method: N.ObjectMethod | N.ClassMethod): void {\n      super.checkGetterSetterParams(method);\n      const params = this.getObjectOrClassMethodParams(method);\n      if (params.length > 0) {\n        const param = params[0];\n        if (this.isThisParam(param) && method.kind === \"get\") {\n          this.raise(FlowErrors.GetterMayNotHaveThisParam, { at: param });\n        } else if (this.isThisParam(param)) {\n          this.raise(FlowErrors.SetterMayNotHaveThisParam, { at: param });\n        }\n      }\n    }\n\n    parsePropertyNamePrefixOperator(\n      node: N.ObjectOrClassMember | N.ClassMember,\n    ): void {\n      node.variance = this.flowParseVariance();\n    }\n\n    // parse type parameters for object method shorthand\n    parseObjPropValue(\n      prop: Undone<N.ObjectMethod | N.ObjectProperty>,\n      startLoc: Position | undefined | null,\n      isGenerator: boolean,\n      isAsync: boolean,\n      isPattern: boolean,\n      isAccessor: boolean,\n      refExpressionErrors?: ExpressionErrors | null,\n    ): N.ObjectMethod | N.ObjectProperty {\n      if ((prop as any).variance) {\n        this.unexpected((prop as any).variance.loc.start);\n      }\n      delete (prop as any).variance;\n\n      let typeParameters;\n\n      // method shorthand\n      if (this.match(tt.lt) && !isAccessor) {\n        typeParameters = this.flowParseTypeParameterDeclaration();\n        if (!this.match(tt.parenL)) this.unexpected();\n      }\n\n      const result = super.parseObjPropValue(\n        prop,\n        startLoc,\n        isGenerator,\n        isAsync,\n        isPattern,\n        isAccessor,\n        refExpressionErrors,\n      );\n\n      // add typeParameters if we found them\n      if (typeParameters) {\n        (result.value || result).typeParameters = typeParameters;\n      }\n      return result;\n    }\n\n    parseAssignableListItemTypes(param: N.Pattern): N.Pattern {\n      if (this.eat(tt.question)) {\n        if (param.type !== \"Identifier\") {\n          this.raise(FlowErrors.PatternIsOptional, { at: param });\n        }\n        if (this.isThisParam(param)) {\n          this.raise(FlowErrors.ThisParamMayNotBeOptional, { at: param });\n        }\n\n        (param as any as N.Identifier).optional = true;\n      }\n      if (this.match(tt.colon)) {\n        // @ts-expect-error: refine typings\n        param.typeAnnotation = this.flowParseTypeAnnotation();\n      } else if (this.isThisParam(param)) {\n        this.raise(FlowErrors.ThisParamAnnotationRequired, { at: param });\n      }\n\n      if (this.match(tt.eq) && this.isThisParam(param)) {\n        this.raise(FlowErrors.ThisParamNoDefault, { at: param });\n      }\n\n      this.resetEndLocation(param);\n      return param;\n    }\n\n    parseMaybeDefault(\n      startLoc?: Position | null,\n      left?: N.Pattern | null,\n    ): N.Pattern {\n      const node = super.parseMaybeDefault(startLoc, left);\n\n      if (\n        node.type === \"AssignmentPattern\" &&\n        node.typeAnnotation &&\n        node.right.start < node.typeAnnotation.start\n      ) {\n        this.raise(FlowErrors.TypeBeforeInitializer, {\n          at: node.typeAnnotation,\n        });\n      }\n\n      return node;\n    }\n\n    checkImportReflection(node: Undone<N.ImportDeclaration>) {\n      super.checkImportReflection(node);\n      if (node.module && node.importKind !== \"value\") {\n        this.raise(FlowErrors.ImportReflectionHasImportType, {\n          at: node.specifiers[0].loc.start,\n        });\n      }\n    }\n\n    parseImportSpecifierLocal<\n      T extends\n        | N.ImportSpecifier\n        | N.ImportDefaultSpecifier\n        | N.ImportNamespaceSpecifier,\n    >(node: N.ImportDeclaration, specifier: Undone<T>, type: T[\"type\"]): void {\n      specifier.local = hasTypeImportKind(node)\n        ? this.flowParseRestrictedIdentifier(\n            /* liberal */ true,\n            /* declaration */ true,\n          )\n        : this.parseIdentifier();\n\n      node.specifiers.push(this.finishImportSpecifier(specifier, type));\n    }\n\n    isPotentialImportPhase(isExport: boolean): boolean {\n      if (super.isPotentialImportPhase(isExport)) return true;\n      if (this.isContextual(tt._type)) {\n        if (!isExport) return true;\n        const ch = this.lookaheadCharCode();\n        return ch === charCodes.leftCurlyBrace || ch === charCodes.asterisk;\n      }\n      return !isExport && this.isContextual(tt._typeof);\n    }\n\n    applyImportPhase(\n      node: Undone<N.ImportDeclaration | N.ExportNamedDeclaration>,\n      isExport: boolean,\n      phase: string | null,\n      loc?: Position,\n    ): void {\n      super.applyImportPhase(node, isExport, phase, loc);\n      if (isExport) {\n        if (!phase && this.match(tt._default)) {\n          // TODO: Align with our TS AST and always add .exportKind\n          return;\n        }\n        (node as N.ExportNamedDeclaration).exportKind =\n          phase === \"type\" ? phase : \"value\";\n      } else {\n        if (phase === \"type\" && this.match(tt.star)) this.unexpected();\n        (node as N.ImportDeclaration).importKind =\n          phase === \"type\" || phase === \"typeof\" ? phase : \"value\";\n      }\n    }\n\n    // parse import-type/typeof shorthand\n    parseImportSpecifier(\n      specifier: any,\n      importedIsString: boolean,\n      isInTypeOnlyImport: boolean,\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n      isMaybeTypeOnly: boolean,\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n      bindingType: BindingTypes | undefined,\n    ): N.ImportSpecifier {\n      const firstIdent = specifier.imported;\n\n      let specifierTypeKind = null;\n      if (firstIdent.type === \"Identifier\") {\n        if (firstIdent.name === \"type\") {\n          specifierTypeKind = \"type\";\n        } else if (firstIdent.name === \"typeof\") {\n          specifierTypeKind = \"typeof\";\n        }\n      }\n\n      let isBinding = false;\n      if (this.isContextual(tt._as) && !this.isLookaheadContextual(\"as\")) {\n        const as_ident = this.parseIdentifier(true);\n        if (\n          specifierTypeKind !== null &&\n          !tokenIsKeywordOrIdentifier(this.state.type)\n        ) {\n          // `import {type as ,` or `import {type as }`\n          specifier.imported = as_ident;\n          specifier.importKind = specifierTypeKind;\n          specifier.local = cloneIdentifier(as_ident);\n        } else {\n          // `import {type as foo`\n          specifier.imported = firstIdent;\n          specifier.importKind = null;\n          specifier.local = this.parseIdentifier();\n        }\n      } else {\n        if (\n          specifierTypeKind !== null &&\n          tokenIsKeywordOrIdentifier(this.state.type)\n        ) {\n          // `import {type foo`\n          specifier.imported = this.parseIdentifier(true);\n          specifier.importKind = specifierTypeKind;\n        } else {\n          if (importedIsString) {\n            /*:: invariant(firstIdent instanceof N.StringLiteral) */\n            throw this.raise(Errors.ImportBindingIsString, {\n              at: specifier,\n              importName: firstIdent.value,\n            });\n          }\n          /*:: invariant(firstIdent instanceof N.Node) */\n          specifier.imported = firstIdent;\n          specifier.importKind = null;\n        }\n\n        if (this.eatContextual(tt._as)) {\n          specifier.local = this.parseIdentifier();\n        } else {\n          isBinding = true;\n          specifier.local = cloneIdentifier(specifier.imported);\n        }\n      }\n\n      const specifierIsTypeImport = hasTypeImportKind(specifier);\n\n      if (isInTypeOnlyImport && specifierIsTypeImport) {\n        this.raise(FlowErrors.ImportTypeShorthandOnlyInPureImport, {\n          at: specifier,\n        });\n      }\n\n      if (isInTypeOnlyImport || specifierIsTypeImport) {\n        this.checkReservedType(\n          specifier.local.name,\n          specifier.local.loc.start,\n          /* declaration */ true,\n        );\n      }\n\n      if (isBinding && !isInTypeOnlyImport && !specifierIsTypeImport) {\n        this.checkReservedWord(\n          specifier.local.name,\n          specifier.loc.start,\n          true,\n          true,\n        );\n      }\n\n      return this.finishImportSpecifier(specifier, \"ImportSpecifier\");\n    }\n\n    parseBindingAtom(): N.Pattern {\n      switch (this.state.type) {\n        case tt._this:\n          // \"this\" may be the name of a parameter, so allow it.\n          return this.parseIdentifier(/* liberal */ true);\n        default:\n          return super.parseBindingAtom();\n      }\n    }\n\n    // parse function type parameters - function foo<T>() {}\n    parseFunctionParams(\n      node: Undone<N.Function>,\n      isConstructor: boolean,\n    ): void {\n      // @ts-expect-error kind may not index node\n      const kind = node.kind;\n      if (kind !== \"get\" && kind !== \"set\" && this.match(tt.lt)) {\n        node.typeParameters = this.flowParseTypeParameterDeclaration();\n      }\n      super.parseFunctionParams(node, isConstructor);\n    }\n\n    // parse flow type annotations on variable declarator heads - let foo: string = bar\n    parseVarId(\n      decl: N.VariableDeclarator,\n      kind: \"var\" | \"let\" | \"const\",\n    ): void {\n      super.parseVarId(decl, kind);\n      if (this.match(tt.colon)) {\n        // @ts-expect-error: refine typings\n        decl.id.typeAnnotation = this.flowParseTypeAnnotation();\n        this.resetEndLocation(decl.id); // set end position to end of type\n      }\n    }\n\n    // parse the return type of an async arrow function - let foo = (async (): number => {});\n    parseAsyncArrowFromCallExpression(\n      node: N.ArrowFunctionExpression,\n      call: N.CallExpression,\n    ): N.ArrowFunctionExpression {\n      if (this.match(tt.colon)) {\n        const oldNoAnonFunctionType = this.state.noAnonFunctionType;\n        this.state.noAnonFunctionType = true;\n        // @ts-expect-error refine typings\n        node.returnType = this.flowParseTypeAnnotation();\n        this.state.noAnonFunctionType = oldNoAnonFunctionType;\n      }\n\n      return super.parseAsyncArrowFromCallExpression(node, call);\n    }\n\n    // todo description\n    shouldParseAsyncArrow(): boolean {\n      return this.match(tt.colon) || super.shouldParseAsyncArrow();\n    }\n\n    // We need to support type parameter declarations for arrow functions. This\n    // is tricky. There are three situations we need to handle\n    //\n    // 1. This is either JSX or an arrow function. We'll try JSX first. If that\n    //    fails, we'll try an arrow function. If that fails, we'll throw the JSX\n    //    error.\n    // 2. This is an arrow function. We'll parse the type parameter declaration,\n    //    parse the rest, make sure the rest is an arrow function, and go from\n    //    there\n    // 3. This is neither. Just call the super method\n    parseMaybeAssign(\n      refExpressionErrors?: ExpressionErrors | null,\n      afterLeftParse?: Function,\n    ): N.Expression {\n      let state = null;\n\n      let jsx;\n\n      if (\n        this.hasPlugin(\"jsx\") &&\n        (this.match(tt.jsxTagStart) || this.match(tt.lt))\n      ) {\n        state = this.state.clone();\n\n        jsx = this.tryParse(\n          () => super.parseMaybeAssign(refExpressionErrors, afterLeftParse),\n          state,\n        );\n\n        /*:: invariant(!jsx.aborted) */\n        /*:: invariant(jsx.node != null) */\n        if (!jsx.error) return jsx.node;\n\n        // Remove `tc.j_expr` and `tc.j_oTag` from context added\n        // by parsing `jsxTagStart` to stop the JSX plugin from\n        // messing with the tokens\n        const { context } = this.state;\n        const currentContext = context[context.length - 1];\n        if (currentContext === tc.j_oTag || currentContext === tc.j_expr) {\n          context.pop();\n        }\n      }\n\n      if (jsx?.error || this.match(tt.lt)) {\n        state = state || this.state.clone();\n\n        let typeParameters: N.TypeParameterDeclaration;\n\n        const arrow = this.tryParse(abort => {\n          typeParameters = this.flowParseTypeParameterDeclaration();\n\n          const arrowExpression = this.forwardNoArrowParamsConversionAt(\n            typeParameters,\n            () => {\n              const result = super.parseMaybeAssign(\n                refExpressionErrors,\n                afterLeftParse,\n              );\n\n              this.resetStartLocationFromNode(result, typeParameters);\n\n              return result;\n            },\n          );\n\n          // <T>(() => {});\n          // <T>(() => {}: any);\n          if (arrowExpression.extra?.parenthesized) abort();\n\n          // The above can return a TypeCastExpression when the arrow\n          // expression is not wrapped in parens. See also `this.parseParenItem`.\n          // (<T>() => {}: any);\n          const expr = this.maybeUnwrapTypeCastExpression(arrowExpression);\n\n          if (expr.type !== \"ArrowFunctionExpression\") abort();\n\n          expr.typeParameters = typeParameters;\n          this.resetStartLocationFromNode(expr, typeParameters);\n\n          return arrowExpression;\n        }, state);\n\n        let arrowExpression:\n          | N.ArrowFunctionExpression\n          | N.TypeCastExpression\n          | undefined\n          | null = null;\n\n        if (\n          arrow.node &&\n          // @ts-expect-error: refine tryParse typings\n          this.maybeUnwrapTypeCastExpression(arrow.node).type ===\n            \"ArrowFunctionExpression\"\n        ) {\n          if (!arrow.error && !arrow.aborted) {\n            // <T> async () => {}\n            // @ts-expect-error: refine tryParse typings\n            if (arrow.node.async) {\n              /*:: invariant(typeParameters) */\n              this.raise(\n                FlowErrors.UnexpectedTypeParameterBeforeAsyncArrowFunction,\n                { at: typeParameters },\n              );\n            }\n            // @ts-expect-error: refine tryParse typings\n            return arrow.node;\n          }\n\n          // @ts-expect-error: refine typings\n          arrowExpression = arrow.node;\n        }\n\n        // If we are here, both JSX and Flow parsing attempts failed.\n        // Give the precedence to the JSX error, except if JSX had an\n        // unrecoverable error while Flow didn't.\n        // If the error is recoverable, we can only re-report it if there is\n        // a node we can return.\n\n        if (jsx?.node) {\n          /*:: invariant(jsx.failState) */\n          this.state = jsx.failState;\n          return jsx.node;\n        }\n\n        if (arrowExpression) {\n          /*:: invariant(arrow.failState) */\n          this.state = arrow.failState;\n          return arrowExpression;\n        }\n\n        if (jsx?.thrown) throw jsx.error;\n        if (arrow.thrown) throw arrow.error;\n\n        /*:: invariant(typeParameters) */\n        throw this.raise(FlowErrors.UnexpectedTokenAfterTypeParameter, {\n          at: typeParameters,\n        });\n      }\n\n      return super.parseMaybeAssign(refExpressionErrors, afterLeftParse);\n    }\n\n    // handle return types for arrow functions\n    parseArrow(\n      node: Undone<N.ArrowFunctionExpression>,\n    ): Undone<N.ArrowFunctionExpression> | undefined | null {\n      if (this.match(tt.colon)) {\n        // @ts-expect-error todo(flow->ts)\n        const result = this.tryParse(() => {\n          const oldNoAnonFunctionType = this.state.noAnonFunctionType;\n          this.state.noAnonFunctionType = true;\n\n          const typeNode = this.startNode<N.TypeAnnotation>();\n\n          [\n            typeNode.typeAnnotation,\n            // @ts-expect-error (destructuring not supported yet)\n            node.predicate,\n          ] = this.flowParseTypeAndPredicateInitialiser();\n\n          this.state.noAnonFunctionType = oldNoAnonFunctionType;\n\n          if (this.canInsertSemicolon()) this.unexpected();\n          if (!this.match(tt.arrow)) this.unexpected();\n\n          return typeNode;\n        });\n\n        if (result.thrown) return null;\n        /*:: invariant(result.node) */\n\n        if (result.error) this.state = result.failState;\n\n        // assign after it is clear it is an arrow\n        // @ts-expect-error todo(flow->ts)\n        node.returnType = result.node.typeAnnotation\n          ? this.finishNode(result.node, \"TypeAnnotation\")\n          : null;\n      }\n\n      return super.parseArrow(node);\n    }\n\n    shouldParseArrow(params: Array<N.Node>): boolean {\n      return this.match(tt.colon) || super.shouldParseArrow(params);\n    }\n\n    setArrowFunctionParameters(\n      node: N.ArrowFunctionExpression,\n      params: N.Pattern[],\n    ): void {\n      if (this.state.noArrowParamsConversionAt.indexOf(node.start) !== -1) {\n        node.params = params;\n      } else {\n        super.setArrowFunctionParameters(node, params);\n      }\n    }\n\n    checkParams(\n      node: N.Function,\n      allowDuplicates: boolean,\n      isArrowFunction?: boolean | null,\n      strictModeChanged: boolean = true,\n    ): void {\n      if (\n        isArrowFunction &&\n        this.state.noArrowParamsConversionAt.indexOf(node.start) !== -1\n      ) {\n        return;\n      }\n\n      // ensure the `this` param is first, if it exists\n      for (let i = 0; i < node.params.length; i++) {\n        if (this.isThisParam(node.params[i]) && i > 0) {\n          this.raise(FlowErrors.ThisParamMustBeFirst, { at: node.params[i] });\n        }\n      }\n\n      super.checkParams(\n        node,\n        allowDuplicates,\n        isArrowFunction,\n        strictModeChanged,\n      );\n    }\n\n    parseParenAndDistinguishExpression(canBeArrow: boolean): N.Expression {\n      return super.parseParenAndDistinguishExpression(\n        canBeArrow && this.state.noArrowAt.indexOf(this.state.start) === -1,\n      );\n    }\n\n    parseSubscripts(\n      base: N.Expression,\n\n      startLoc: Position,\n      noCalls?: boolean | null,\n    ): N.Expression {\n      if (\n        base.type === \"Identifier\" &&\n        base.name === \"async\" &&\n        this.state.noArrowAt.indexOf(startLoc.index) !== -1\n      ) {\n        this.next();\n\n        const node = this.startNodeAt(startLoc);\n        node.callee = base;\n        node.arguments = super.parseCallExpressionArguments(tt.parenR, false);\n        base = this.finishNode(node, \"CallExpression\");\n      } else if (\n        base.type === \"Identifier\" &&\n        base.name === \"async\" &&\n        this.match(tt.lt)\n      ) {\n        const state = this.state.clone();\n        const arrow = this.tryParse(\n          abort => this.parseAsyncArrowWithTypeParameters(startLoc) || abort(),\n          state,\n        );\n\n        /*:: invariant(arrow.node != null) */\n        // @ts-expect-error: refine tryParse typings\n        if (!arrow.error && !arrow.aborted) return arrow.node;\n\n        const result = this.tryParse(\n          () => super.parseSubscripts(base, startLoc, noCalls),\n          state,\n        );\n\n        if (result.node && !result.error) return result.node;\n\n        if (arrow.node) {\n          this.state = arrow.failState;\n          // @ts-expect-error: refine tryParse typings\n          return arrow.node;\n        }\n\n        if (result.node) {\n          this.state = result.failState;\n          return result.node;\n        }\n\n        throw arrow.error || result.error;\n      }\n\n      return super.parseSubscripts(base, startLoc, noCalls);\n    }\n\n    parseSubscript(\n      base: N.Expression,\n\n      startLoc: Position,\n      noCalls: boolean | undefined | null,\n      subscriptState: N.ParseSubscriptState,\n    ): N.Expression {\n      if (this.match(tt.questionDot) && this.isLookaheadToken_lt()) {\n        subscriptState.optionalChainMember = true;\n        if (noCalls) {\n          subscriptState.stop = true;\n          return base;\n        }\n        this.next();\n        const node = this.startNodeAt<N.OptionalCallExpression>(startLoc);\n        node.callee = base;\n        node.typeArguments = this.flowParseTypeParameterInstantiation();\n        this.expect(tt.parenL);\n        node.arguments = this.parseCallExpressionArguments(tt.parenR, false);\n        node.optional = true;\n        return this.finishCallExpression(node, /* optional */ true);\n      } else if (!noCalls && this.shouldParseTypes() && this.match(tt.lt)) {\n        const node = this.startNodeAt<\n          N.OptionalCallExpression | N.CallExpression\n        >(startLoc);\n        node.callee = base;\n\n        const result = this.tryParse(() => {\n          node.typeArguments =\n            this.flowParseTypeParameterInstantiationCallOrNew();\n          this.expect(tt.parenL);\n          node.arguments = super.parseCallExpressionArguments(tt.parenR, false);\n          if (subscriptState.optionalChainMember) {\n            (node as Undone<N.OptionalCallExpression>).optional = false;\n          }\n          return this.finishCallExpression(\n            node,\n            subscriptState.optionalChainMember,\n          );\n        });\n\n        if (result.node) {\n          if (result.error) this.state = result.failState;\n          return result.node;\n        }\n      }\n\n      return super.parseSubscript(\n        base,\n\n        startLoc,\n        noCalls,\n        subscriptState,\n      );\n    }\n\n    parseNewCallee(node: N.NewExpression): void {\n      super.parseNewCallee(node);\n\n      let targs = null;\n      if (this.shouldParseTypes() && this.match(tt.lt)) {\n        targs = this.tryParse(() =>\n          this.flowParseTypeParameterInstantiationCallOrNew(),\n        ).node;\n      }\n      node.typeArguments = targs;\n    }\n\n    parseAsyncArrowWithTypeParameters(\n      startLoc: Position,\n    ): N.ArrowFunctionExpression | undefined | null {\n      const node = this.startNodeAt<N.ArrowFunctionExpression>(startLoc);\n      this.parseFunctionParams(node, false);\n      if (!this.parseArrow(node)) return;\n      return super.parseArrowExpression(\n        node,\n        /* params */ undefined,\n        /* isAsync */ true,\n      );\n    }\n\n    readToken_mult_modulo(code: number): void {\n      const next = this.input.charCodeAt(this.state.pos + 1);\n      if (\n        code === charCodes.asterisk &&\n        next === charCodes.slash &&\n        this.state.hasFlowComment\n      ) {\n        this.state.hasFlowComment = false;\n        this.state.pos += 2;\n        this.nextToken();\n        return;\n      }\n\n      super.readToken_mult_modulo(code);\n    }\n\n    readToken_pipe_amp(code: number): void {\n      const next = this.input.charCodeAt(this.state.pos + 1);\n      if (\n        code === charCodes.verticalBar &&\n        next === charCodes.rightCurlyBrace\n      ) {\n        // '|}'\n        this.finishOp(tt.braceBarR, 2);\n        return;\n      }\n\n      super.readToken_pipe_amp(code);\n    }\n\n    parseTopLevel(file: N.File, program: N.Program): N.File {\n      const fileNode = super.parseTopLevel(file, program);\n      if (this.state.hasFlowComment) {\n        this.raise(FlowErrors.UnterminatedFlowComment, {\n          at: this.state.curPosition(),\n        });\n      }\n      return fileNode;\n    }\n\n    skipBlockComment(): N.CommentBlock | undefined {\n      if (this.hasPlugin(\"flowComments\") && this.skipFlowComment()) {\n        if (this.state.hasFlowComment) {\n          throw this.raise(FlowErrors.NestedFlowComment, {\n            at: this.state.startLoc,\n          });\n        }\n        this.hasFlowCommentCompletion();\n        const commentSkip = this.skipFlowComment();\n        if (commentSkip) {\n          this.state.pos += commentSkip;\n          this.state.hasFlowComment = true;\n        }\n        return;\n      }\n\n      return super.skipBlockComment(this.state.hasFlowComment ? \"*-/\" : \"*/\");\n    }\n\n    skipFlowComment(): number | false {\n      const { pos } = this.state;\n      let shiftToFirstNonWhiteSpace = 2;\n      while (\n        [charCodes.space, charCodes.tab].includes(\n          // @ts-expect-error testing whether a number is included\n          this.input.charCodeAt(pos + shiftToFirstNonWhiteSpace),\n        )\n      ) {\n        shiftToFirstNonWhiteSpace++;\n      }\n\n      const ch2 = this.input.charCodeAt(shiftToFirstNonWhiteSpace + pos);\n      const ch3 = this.input.charCodeAt(shiftToFirstNonWhiteSpace + pos + 1);\n\n      if (ch2 === charCodes.colon && ch3 === charCodes.colon) {\n        return shiftToFirstNonWhiteSpace + 2; // check for /*::\n      }\n      if (\n        this.input.slice(\n          shiftToFirstNonWhiteSpace + pos,\n          shiftToFirstNonWhiteSpace + pos + 12,\n        ) === \"flow-include\"\n      ) {\n        return shiftToFirstNonWhiteSpace + 12; // check for /*flow-include\n      }\n      if (ch2 === charCodes.colon && ch3 !== charCodes.colon) {\n        return shiftToFirstNonWhiteSpace; // check for /*:, advance up to :\n      }\n      return false;\n    }\n\n    hasFlowCommentCompletion(): void {\n      const end = this.input.indexOf(\"*/\", this.state.pos);\n      if (end === -1) {\n        throw this.raise(Errors.UnterminatedComment, {\n          at: this.state.curPosition(),\n        });\n      }\n    }\n\n    // Flow enum parsing\n\n    flowEnumErrorBooleanMemberNotInitialized(\n      loc: Position,\n      {\n        enumName,\n        memberName,\n      }: {\n        enumName: string;\n        memberName: string;\n      },\n    ): void {\n      this.raise(FlowErrors.EnumBooleanMemberNotInitialized, {\n        at: loc,\n        memberName,\n        enumName,\n      });\n    }\n\n    flowEnumErrorInvalidMemberInitializer(\n      loc: Position,\n      enumContext: EnumContext,\n    ) {\n      return this.raise(\n        !enumContext.explicitType\n          ? FlowErrors.EnumInvalidMemberInitializerUnknownType\n          : enumContext.explicitType === \"symbol\"\n          ? FlowErrors.EnumInvalidMemberInitializerSymbolType\n          : FlowErrors.EnumInvalidMemberInitializerPrimaryType,\n        {\n          at: loc,\n          ...enumContext,\n        },\n      );\n    }\n\n    flowEnumErrorNumberMemberNotInitialized(\n      loc: Position,\n      {\n        enumName,\n        memberName,\n      }: {\n        enumName: string;\n        memberName: string;\n      },\n    ): void {\n      this.raise(FlowErrors.EnumNumberMemberNotInitialized, {\n        at: loc,\n        enumName,\n        memberName,\n      });\n    }\n\n    flowEnumErrorStringMemberInconsistentlyInitailized(\n      node: N.Node,\n      {\n        enumName,\n      }: {\n        enumName: string;\n      },\n    ): void {\n      this.raise(FlowErrors.EnumStringMemberInconsistentlyInitailized, {\n        at: node,\n        enumName,\n      });\n    }\n\n    flowEnumMemberInit(): EnumMemberInit {\n      const startLoc = this.state.startLoc;\n      const endOfInit = () => this.match(tt.comma) || this.match(tt.braceR);\n      switch (this.state.type) {\n        case tt.num: {\n          const literal = this.parseNumericLiteral(this.state.value);\n          if (endOfInit()) {\n            return { type: \"number\", loc: literal.loc.start, value: literal };\n          }\n          return { type: \"invalid\", loc: startLoc };\n        }\n        case tt.string: {\n          const literal = this.parseStringLiteral(this.state.value);\n          if (endOfInit()) {\n            return { type: \"string\", loc: literal.loc.start, value: literal };\n          }\n          return { type: \"invalid\", loc: startLoc };\n        }\n        case tt._true:\n        case tt._false: {\n          const literal = this.parseBooleanLiteral(this.match(tt._true));\n          if (endOfInit()) {\n            return {\n              type: \"boolean\",\n              loc: literal.loc.start,\n              value: literal,\n            };\n          }\n          return { type: \"invalid\", loc: startLoc };\n        }\n        default:\n          return { type: \"invalid\", loc: startLoc };\n      }\n    }\n\n    flowEnumMemberRaw(): {\n      id: N.Node;\n      init: EnumMemberInit;\n    } {\n      const loc = this.state.startLoc;\n      const id = this.parseIdentifier(true);\n      const init = this.eat(tt.eq)\n        ? this.flowEnumMemberInit()\n        : { type: \"none\" as const, loc };\n      return { id, init };\n    }\n\n    flowEnumCheckExplicitTypeMismatch(\n      loc: Position,\n      context: EnumContext,\n      expectedType: EnumExplicitType,\n    ): void {\n      const { explicitType } = context;\n      if (explicitType === null) {\n        return;\n      }\n      if (explicitType !== expectedType) {\n        this.flowEnumErrorInvalidMemberInitializer(loc, context);\n      }\n    }\n\n    flowEnumMembers({\n      enumName,\n      explicitType,\n    }: {\n      enumName: string;\n      explicitType: EnumExplicitType;\n    }): {\n      members: {\n        booleanMembers: Array<N.Node>;\n        numberMembers: Array<N.Node>;\n        stringMembers: Array<N.Node>;\n        defaultedMembers: Array<N.Node>;\n      };\n      hasUnknownMembers: boolean;\n    } {\n      const seenNames = new Set();\n      const members = {\n        // @ts-expect-error: migrate to Babel types\n        booleanMembers: [],\n        // @ts-expect-error: migrate to Babel types\n        numberMembers: [],\n        // @ts-expect-error: migrate to Babel types\n        stringMembers: [],\n        // @ts-expect-error: migrate to Babel types\n        defaultedMembers: [],\n      };\n      let hasUnknownMembers = false;\n      while (!this.match(tt.braceR)) {\n        if (this.eat(tt.ellipsis)) {\n          hasUnknownMembers = true;\n          break;\n        }\n        const memberNode = this.startNode();\n        const { id, init } = this.flowEnumMemberRaw();\n        const memberName = id.name;\n        if (memberName === \"\") {\n          continue;\n        }\n        if (/^[a-z]/.test(memberName)) {\n          this.raise(FlowErrors.EnumInvalidMemberName, {\n            at: id,\n            memberName,\n            suggestion: memberName[0].toUpperCase() + memberName.slice(1),\n            enumName,\n          });\n        }\n        if (seenNames.has(memberName)) {\n          this.raise(FlowErrors.EnumDuplicateMemberName, {\n            at: id,\n            memberName,\n            enumName,\n          });\n        }\n        seenNames.add(memberName);\n        const context = { enumName, explicitType, memberName };\n        memberNode.id = id;\n        switch (init.type) {\n          case \"boolean\": {\n            this.flowEnumCheckExplicitTypeMismatch(\n              init.loc,\n              context,\n              \"boolean\",\n            );\n            memberNode.init = init.value;\n            members.booleanMembers.push(\n              this.finishNode(memberNode, \"EnumBooleanMember\"),\n            );\n            break;\n          }\n          case \"number\": {\n            this.flowEnumCheckExplicitTypeMismatch(init.loc, context, \"number\");\n            memberNode.init = init.value;\n            members.numberMembers.push(\n              this.finishNode(memberNode, \"EnumNumberMember\"),\n            );\n            break;\n          }\n          case \"string\": {\n            this.flowEnumCheckExplicitTypeMismatch(init.loc, context, \"string\");\n            memberNode.init = init.value;\n            members.stringMembers.push(\n              this.finishNode(memberNode, \"EnumStringMember\"),\n            );\n            break;\n          }\n          case \"invalid\": {\n            throw this.flowEnumErrorInvalidMemberInitializer(init.loc, context);\n          }\n          case \"none\": {\n            switch (explicitType) {\n              case \"boolean\":\n                this.flowEnumErrorBooleanMemberNotInitialized(\n                  init.loc,\n                  context,\n                );\n                break;\n              case \"number\":\n                this.flowEnumErrorNumberMemberNotInitialized(init.loc, context);\n                break;\n              default:\n                members.defaultedMembers.push(\n                  this.finishNode(memberNode, \"EnumDefaultedMember\"),\n                );\n            }\n          }\n        }\n\n        if (!this.match(tt.braceR)) {\n          this.expect(tt.comma);\n        }\n      }\n      return { members, hasUnknownMembers };\n    }\n\n    flowEnumStringMembers(\n      initializedMembers: Array<N.Node>,\n      defaultedMembers: Array<N.Node>,\n      {\n        enumName,\n      }: {\n        enumName: string;\n      },\n    ): Array<N.Node> {\n      if (initializedMembers.length === 0) {\n        return defaultedMembers;\n      } else if (defaultedMembers.length === 0) {\n        return initializedMembers;\n      } else if (defaultedMembers.length > initializedMembers.length) {\n        for (const member of initializedMembers) {\n          this.flowEnumErrorStringMemberInconsistentlyInitailized(member, {\n            enumName,\n          });\n        }\n        return defaultedMembers;\n      } else {\n        for (const member of defaultedMembers) {\n          this.flowEnumErrorStringMemberInconsistentlyInitailized(member, {\n            enumName,\n          });\n        }\n        return initializedMembers;\n      }\n    }\n\n    flowEnumParseExplicitType({\n      enumName,\n    }: {\n      enumName: string;\n    }): EnumExplicitType {\n      if (!this.eatContextual(tt._of)) return null;\n\n      if (!tokenIsIdentifier(this.state.type)) {\n        throw this.raise(FlowErrors.EnumInvalidExplicitTypeUnknownSupplied, {\n          at: this.state.startLoc,\n          enumName,\n        });\n      }\n\n      const { value } = this.state;\n      this.next();\n\n      if (\n        value !== \"boolean\" &&\n        value !== \"number\" &&\n        value !== \"string\" &&\n        value !== \"symbol\"\n      ) {\n        this.raise(FlowErrors.EnumInvalidExplicitType, {\n          at: this.state.startLoc,\n          enumName,\n          invalidEnumType: value,\n        });\n      }\n\n      return value;\n    }\n\n    flowEnumBody(node: Undone<N.Node>, id: N.Node): N.Node {\n      const enumName = id.name;\n      const nameLoc = id.loc.start;\n      const explicitType = this.flowEnumParseExplicitType({ enumName });\n      this.expect(tt.braceL);\n      const { members, hasUnknownMembers } = this.flowEnumMembers({\n        enumName,\n        explicitType,\n      });\n      node.hasUnknownMembers = hasUnknownMembers;\n\n      switch (explicitType) {\n        case \"boolean\":\n          node.explicitType = true;\n          node.members = members.booleanMembers;\n          this.expect(tt.braceR);\n          return this.finishNode(node, \"EnumBooleanBody\");\n        case \"number\":\n          node.explicitType = true;\n          node.members = members.numberMembers;\n          this.expect(tt.braceR);\n          return this.finishNode(node, \"EnumNumberBody\");\n        case \"string\":\n          node.explicitType = true;\n          node.members = this.flowEnumStringMembers(\n            members.stringMembers,\n            members.defaultedMembers,\n            { enumName },\n          );\n          this.expect(tt.braceR);\n          return this.finishNode(node, \"EnumStringBody\");\n        case \"symbol\":\n          node.members = members.defaultedMembers;\n          this.expect(tt.braceR);\n          return this.finishNode(node, \"EnumSymbolBody\");\n        default: {\n          // `explicitType` is `null`\n          const empty = () => {\n            node.members = [];\n            this.expect(tt.braceR);\n            return this.finishNode(node, \"EnumStringBody\");\n          };\n          node.explicitType = false;\n\n          const boolsLen = members.booleanMembers.length;\n          const numsLen = members.numberMembers.length;\n          const strsLen = members.stringMembers.length;\n          const defaultedLen = members.defaultedMembers.length;\n\n          if (!boolsLen && !numsLen && !strsLen && !defaultedLen) {\n            return empty();\n          } else if (!boolsLen && !numsLen) {\n            node.members = this.flowEnumStringMembers(\n              members.stringMembers,\n              members.defaultedMembers,\n              { enumName },\n            );\n            this.expect(tt.braceR);\n            return this.finishNode(node, \"EnumStringBody\");\n          } else if (!numsLen && !strsLen && boolsLen >= defaultedLen) {\n            for (const member of members.defaultedMembers) {\n              this.flowEnumErrorBooleanMemberNotInitialized(member.loc.start, {\n                enumName,\n                memberName: member.id.name,\n              });\n            }\n            node.members = members.booleanMembers;\n            this.expect(tt.braceR);\n            return this.finishNode(node, \"EnumBooleanBody\");\n          } else if (!boolsLen && !strsLen && numsLen >= defaultedLen) {\n            for (const member of members.defaultedMembers) {\n              this.flowEnumErrorNumberMemberNotInitialized(member.loc.start, {\n                enumName,\n                memberName: member.id.name,\n              });\n            }\n            node.members = members.numberMembers;\n            this.expect(tt.braceR);\n            return this.finishNode(node, \"EnumNumberBody\");\n          } else {\n            this.raise(FlowErrors.EnumInconsistentMemberValues, {\n              at: nameLoc,\n              enumName,\n            });\n            return empty();\n          }\n        }\n      }\n    }\n\n    flowParseEnumDeclaration(node: Undone<N.Node>): N.Node {\n      const id = this.parseIdentifier();\n      node.id = id;\n      node.body = this.flowEnumBody(this.startNode(), id);\n      return this.finishNode(node, \"EnumDeclaration\");\n    }\n\n    // check if the next token is a tt.lt\n    isLookaheadToken_lt(): boolean {\n      const next = this.nextTokenStart();\n      if (this.input.charCodeAt(next) === charCodes.lessThan) {\n        const afterNext = this.input.charCodeAt(next + 1);\n        return (\n          afterNext !== charCodes.lessThan && afterNext !== charCodes.equalsTo\n        );\n      }\n      return false;\n    }\n\n    maybeUnwrapTypeCastExpression(node: N.Node) {\n      return node.type === \"TypeCastExpression\" ? node.expression : node;\n    }\n  };\n","const entities: {\n  __proto__: null;\n  [name: string]: string;\n} = {\n  __proto__: null,\n  quot: \"\\u0022\",\n  amp: \"&\",\n  apos: \"\\u0027\",\n  lt: \"<\",\n  gt: \">\",\n  nbsp: \"\\u00A0\",\n  iexcl: \"\\u00A1\",\n  cent: \"\\u00A2\",\n  pound: \"\\u00A3\",\n  curren: \"\\u00A4\",\n  yen: \"\\u00A5\",\n  brvbar: \"\\u00A6\",\n  sect: \"\\u00A7\",\n  uml: \"\\u00A8\",\n  copy: \"\\u00A9\",\n  ordf: \"\\u00AA\",\n  laquo: \"\\u00AB\",\n  not: \"\\u00AC\",\n  shy: \"\\u00AD\",\n  reg: \"\\u00AE\",\n  macr: \"\\u00AF\",\n  deg: \"\\u00B0\",\n  plusmn: \"\\u00B1\",\n  sup2: \"\\u00B2\",\n  sup3: \"\\u00B3\",\n  acute: \"\\u00B4\",\n  micro: \"\\u00B5\",\n  para: \"\\u00B6\",\n  middot: \"\\u00B7\",\n  cedil: \"\\u00B8\",\n  sup1: \"\\u00B9\",\n  ordm: \"\\u00BA\",\n  raquo: \"\\u00BB\",\n  frac14: \"\\u00BC\",\n  frac12: \"\\u00BD\",\n  frac34: \"\\u00BE\",\n  iquest: \"\\u00BF\",\n  Agrave: \"\\u00C0\",\n  Aacute: \"\\u00C1\",\n  Acirc: \"\\u00C2\",\n  Atilde: \"\\u00C3\",\n  Auml: \"\\u00C4\",\n  Aring: \"\\u00C5\",\n  AElig: \"\\u00C6\",\n  Ccedil: \"\\u00C7\",\n  Egrave: \"\\u00C8\",\n  Eacute: \"\\u00C9\",\n  Ecirc: \"\\u00CA\",\n  Euml: \"\\u00CB\",\n  Igrave: \"\\u00CC\",\n  Iacute: \"\\u00CD\",\n  Icirc: \"\\u00CE\",\n  Iuml: \"\\u00CF\",\n  ETH: \"\\u00D0\",\n  Ntilde: \"\\u00D1\",\n  Ograve: \"\\u00D2\",\n  Oacute: \"\\u00D3\",\n  Ocirc: \"\\u00D4\",\n  Otilde: \"\\u00D5\",\n  Ouml: \"\\u00D6\",\n  times: \"\\u00D7\",\n  Oslash: \"\\u00D8\",\n  Ugrave: \"\\u00D9\",\n  Uacute: \"\\u00DA\",\n  Ucirc: \"\\u00DB\",\n  Uuml: \"\\u00DC\",\n  Yacute: \"\\u00DD\",\n  THORN: \"\\u00DE\",\n  szlig: \"\\u00DF\",\n  agrave: \"\\u00E0\",\n  aacute: \"\\u00E1\",\n  acirc: \"\\u00E2\",\n  atilde: \"\\u00E3\",\n  auml: \"\\u00E4\",\n  aring: \"\\u00E5\",\n  aelig: \"\\u00E6\",\n  ccedil: \"\\u00E7\",\n  egrave: \"\\u00E8\",\n  eacute: \"\\u00E9\",\n  ecirc: \"\\u00EA\",\n  euml: \"\\u00EB\",\n  igrave: \"\\u00EC\",\n  iacute: \"\\u00ED\",\n  icirc: \"\\u00EE\",\n  iuml: \"\\u00EF\",\n  eth: \"\\u00F0\",\n  ntilde: \"\\u00F1\",\n  ograve: \"\\u00F2\",\n  oacute: \"\\u00F3\",\n  ocirc: \"\\u00F4\",\n  otilde: \"\\u00F5\",\n  ouml: \"\\u00F6\",\n  divide: \"\\u00F7\",\n  oslash: \"\\u00F8\",\n  ugrave: \"\\u00F9\",\n  uacute: \"\\u00FA\",\n  ucirc: \"\\u00FB\",\n  uuml: \"\\u00FC\",\n  yacute: \"\\u00FD\",\n  thorn: \"\\u00FE\",\n  yuml: \"\\u00FF\",\n  OElig: \"\\u0152\",\n  oelig: \"\\u0153\",\n  Scaron: \"\\u0160\",\n  scaron: \"\\u0161\",\n  Yuml: \"\\u0178\",\n  fnof: \"\\u0192\",\n  circ: \"\\u02C6\",\n  tilde: \"\\u02DC\",\n  Alpha: \"\\u0391\",\n  Beta: \"\\u0392\",\n  Gamma: \"\\u0393\",\n  Delta: \"\\u0394\",\n  Epsilon: \"\\u0395\",\n  Zeta: \"\\u0396\",\n  Eta: \"\\u0397\",\n  Theta: \"\\u0398\",\n  Iota: \"\\u0399\",\n  Kappa: \"\\u039A\",\n  Lambda: \"\\u039B\",\n  Mu: \"\\u039C\",\n  Nu: \"\\u039D\",\n  Xi: \"\\u039E\",\n  Omicron: \"\\u039F\",\n  Pi: \"\\u03A0\",\n  Rho: \"\\u03A1\",\n  Sigma: \"\\u03A3\",\n  Tau: \"\\u03A4\",\n  Upsilon: \"\\u03A5\",\n  Phi: \"\\u03A6\",\n  Chi: \"\\u03A7\",\n  Psi: \"\\u03A8\",\n  Omega: \"\\u03A9\",\n  alpha: \"\\u03B1\",\n  beta: \"\\u03B2\",\n  gamma: \"\\u03B3\",\n  delta: \"\\u03B4\",\n  epsilon: \"\\u03B5\",\n  zeta: \"\\u03B6\",\n  eta: \"\\u03B7\",\n  theta: \"\\u03B8\",\n  iota: \"\\u03B9\",\n  kappa: \"\\u03BA\",\n  lambda: \"\\u03BB\",\n  mu: \"\\u03BC\",\n  nu: \"\\u03BD\",\n  xi: \"\\u03BE\",\n  omicron: \"\\u03BF\",\n  pi: \"\\u03C0\",\n  rho: \"\\u03C1\",\n  sigmaf: \"\\u03C2\",\n  sigma: \"\\u03C3\",\n  tau: \"\\u03C4\",\n  upsilon: \"\\u03C5\",\n  phi: \"\\u03C6\",\n  chi: \"\\u03C7\",\n  psi: \"\\u03C8\",\n  omega: \"\\u03C9\",\n  thetasym: \"\\u03D1\",\n  upsih: \"\\u03D2\",\n  piv: \"\\u03D6\",\n  ensp: \"\\u2002\",\n  emsp: \"\\u2003\",\n  thinsp: \"\\u2009\",\n  zwnj: \"\\u200C\",\n  zwj: \"\\u200D\",\n  lrm: \"\\u200E\",\n  rlm: \"\\u200F\",\n  ndash: \"\\u2013\",\n  mdash: \"\\u2014\",\n  lsquo: \"\\u2018\",\n  rsquo: \"\\u2019\",\n  sbquo: \"\\u201A\",\n  ldquo: \"\\u201C\",\n  rdquo: \"\\u201D\",\n  bdquo: \"\\u201E\",\n  dagger: \"\\u2020\",\n  Dagger: \"\\u2021\",\n  bull: \"\\u2022\",\n  hellip: \"\\u2026\",\n  permil: \"\\u2030\",\n  prime: \"\\u2032\",\n  Prime: \"\\u2033\",\n  lsaquo: \"\\u2039\",\n  rsaquo: \"\\u203A\",\n  oline: \"\\u203E\",\n  frasl: \"\\u2044\",\n  euro: \"\\u20AC\",\n  image: \"\\u2111\",\n  weierp: \"\\u2118\",\n  real: \"\\u211C\",\n  trade: \"\\u2122\",\n  alefsym: \"\\u2135\",\n  larr: \"\\u2190\",\n  uarr: \"\\u2191\",\n  rarr: \"\\u2192\",\n  darr: \"\\u2193\",\n  harr: \"\\u2194\",\n  crarr: \"\\u21B5\",\n  lArr: \"\\u21D0\",\n  uArr: \"\\u21D1\",\n  rArr: \"\\u21D2\",\n  dArr: \"\\u21D3\",\n  hArr: \"\\u21D4\",\n  forall: \"\\u2200\",\n  part: \"\\u2202\",\n  exist: \"\\u2203\",\n  empty: \"\\u2205\",\n  nabla: \"\\u2207\",\n  isin: \"\\u2208\",\n  notin: \"\\u2209\",\n  ni: \"\\u220B\",\n  prod: \"\\u220F\",\n  sum: \"\\u2211\",\n  minus: \"\\u2212\",\n  lowast: \"\\u2217\",\n  radic: \"\\u221A\",\n  prop: \"\\u221D\",\n  infin: \"\\u221E\",\n  ang: \"\\u2220\",\n  and: \"\\u2227\",\n  or: \"\\u2228\",\n  cap: \"\\u2229\",\n  cup: \"\\u222A\",\n  int: \"\\u222B\",\n  there4: \"\\u2234\",\n  sim: \"\\u223C\",\n  cong: \"\\u2245\",\n  asymp: \"\\u2248\",\n  ne: \"\\u2260\",\n  equiv: \"\\u2261\",\n  le: \"\\u2264\",\n  ge: \"\\u2265\",\n  sub: \"\\u2282\",\n  sup: \"\\u2283\",\n  nsub: \"\\u2284\",\n  sube: \"\\u2286\",\n  supe: \"\\u2287\",\n  oplus: \"\\u2295\",\n  otimes: \"\\u2297\",\n  perp: \"\\u22A5\",\n  sdot: \"\\u22C5\",\n  lceil: \"\\u2308\",\n  rceil: \"\\u2309\",\n  lfloor: \"\\u230A\",\n  rfloor: \"\\u230B\",\n  lang: \"\\u2329\",\n  rang: \"\\u232A\",\n  loz: \"\\u25CA\",\n  spades: \"\\u2660\",\n  clubs: \"\\u2663\",\n  hearts: \"\\u2665\",\n  diams: \"\\u2666\",\n} as const;\nexport default entities;\n","import * as charCodes from \"charcodes\";\n\nimport XHTMLEntities from \"./xhtml\";\nimport type Parser from \"../../parser\";\nimport type { ExpressionErrors } from \"../../parser/util\";\nimport {\n  tokenComesBeforeExpression,\n  tokenIsKeyword,\n  tokenLabelName,\n  type TokenType,\n  tt,\n} from \"../../tokenizer/types\";\nimport type { TokContext } from \"../../tokenizer/context\";\nimport { types as tc } from \"../../tokenizer/context\";\nimport type * as N from \"../../types\";\nimport { isIdentifierChar, isIdentifierStart } from \"../../util/identifier\";\nimport type { Position } from \"../../util/location\";\nimport { isNewLine } from \"../../util/whitespace\";\nimport { Errors, ParseErrorEnum } from \"../../parse-error\";\nimport type { Undone } from \"../../parser/node\";\n\n/* eslint sort-keys: \"error\" */\nconst JsxErrors = ParseErrorEnum`jsx`({\n  AttributeIsEmpty:\n    \"JSX attributes must only be assigned a non-empty expression.\",\n  MissingClosingTagElement: ({ openingTagName }: { openingTagName: string }) =>\n    `Expected corresponding JSX closing tag for <${openingTagName}>.`,\n  MissingClosingTagFragment: \"Expected corresponding JSX closing tag for <>.\",\n  UnexpectedSequenceExpression:\n    \"Sequence expressions cannot be directly nested inside JSX. Did you mean to wrap it in parentheses (...)?\",\n  // FIXME: Unify with Errors.UnexpectedToken\n  UnexpectedToken: ({\n    unexpected,\n    HTMLEntity,\n  }: {\n    unexpected: string;\n    HTMLEntity: string;\n  }) =>\n    `Unexpected token \\`${unexpected}\\`. Did you mean \\`${HTMLEntity}\\` or \\`{'${unexpected}'}\\`?`,\n  UnsupportedJsxValue:\n    \"JSX value should be either an expression or a quoted JSX text.\",\n  UnterminatedJsxContent: \"Unterminated JSX contents.\",\n  UnwrappedAdjacentJSXElements:\n    \"Adjacent JSX elements must be wrapped in an enclosing tag. Did you want a JSX fragment <>...</>?\",\n});\n\n/* eslint-disable sort-keys */\n\nfunction isFragment(object?: N.JSXElement | null): boolean {\n  return object\n    ? object.type === \"JSXOpeningFragment\" ||\n        object.type === \"JSXClosingFragment\"\n    : false;\n}\n\n// Transforms JSX element name to string.\n\nfunction getQualifiedJSXName(\n  object: N.JSXIdentifier | N.JSXNamespacedName | N.JSXMemberExpression,\n): string {\n  if (object.type === \"JSXIdentifier\") {\n    return object.name;\n  }\n\n  if (object.type === \"JSXNamespacedName\") {\n    return object.namespace.name + \":\" + object.name.name;\n  }\n\n  if (object.type === \"JSXMemberExpression\") {\n    return (\n      getQualifiedJSXName(object.object) +\n      \".\" +\n      getQualifiedJSXName(object.property)\n    );\n  }\n\n  // istanbul ignore next\n  throw new Error(\"Node had unexpected type: \" + object.type);\n}\n\nexport interface IJSXParserMixin {\n  jsxParseOpeningElementAfterName(\n    node: N.JSXOpeningElement,\n  ): N.JSXOpeningElement;\n}\n\nexport default (superClass: typeof Parser) =>\n  class JSXParserMixin extends superClass implements Parser, IJSXParserMixin {\n    // Reads inline JSX contents token.\n\n    jsxReadToken(): void {\n      let out = \"\";\n      let chunkStart = this.state.pos;\n      for (;;) {\n        if (this.state.pos >= this.length) {\n          throw this.raise(JsxErrors.UnterminatedJsxContent, {\n            at: this.state.startLoc,\n          });\n        }\n\n        const ch = this.input.charCodeAt(this.state.pos);\n\n        switch (ch) {\n          case charCodes.lessThan:\n          case charCodes.leftCurlyBrace:\n            if (this.state.pos === this.state.start) {\n              if (ch === charCodes.lessThan && this.state.canStartJSXElement) {\n                ++this.state.pos;\n                this.finishToken(tt.jsxTagStart);\n              } else {\n                super.getTokenFromCode(ch);\n              }\n              return;\n            }\n            out += this.input.slice(chunkStart, this.state.pos);\n            this.finishToken(tt.jsxText, out);\n            return;\n\n          case charCodes.ampersand:\n            out += this.input.slice(chunkStart, this.state.pos);\n            out += this.jsxReadEntity();\n            chunkStart = this.state.pos;\n            break;\n\n          case charCodes.greaterThan:\n          case charCodes.rightCurlyBrace:\n            if (process.env.BABEL_8_BREAKING) {\n              this.raise(JsxErrors.UnexpectedToken, {\n                at: this.state.curPosition(),\n                unexpected: this.input[this.state.pos],\n                HTMLEntity:\n                  ch === charCodes.rightCurlyBrace ? \"&rbrace;\" : \"&gt;\",\n              });\n            }\n          /* falls through */\n\n          default:\n            if (isNewLine(ch)) {\n              out += this.input.slice(chunkStart, this.state.pos);\n              out += this.jsxReadNewLine(true);\n              chunkStart = this.state.pos;\n            } else {\n              ++this.state.pos;\n            }\n        }\n      }\n    }\n\n    jsxReadNewLine(normalizeCRLF: boolean): string {\n      const ch = this.input.charCodeAt(this.state.pos);\n      let out;\n      ++this.state.pos;\n      if (\n        ch === charCodes.carriageReturn &&\n        this.input.charCodeAt(this.state.pos) === charCodes.lineFeed\n      ) {\n        ++this.state.pos;\n        out = normalizeCRLF ? \"\\n\" : \"\\r\\n\";\n      } else {\n        out = String.fromCharCode(ch);\n      }\n      ++this.state.curLine;\n      this.state.lineStart = this.state.pos;\n\n      return out;\n    }\n\n    jsxReadString(quote: number): void {\n      let out = \"\";\n      let chunkStart = ++this.state.pos;\n      for (;;) {\n        if (this.state.pos >= this.length) {\n          throw this.raise(Errors.UnterminatedString, {\n            at: this.state.startLoc,\n          });\n        }\n\n        const ch = this.input.charCodeAt(this.state.pos);\n        if (ch === quote) break;\n        if (ch === charCodes.ampersand) {\n          out += this.input.slice(chunkStart, this.state.pos);\n          out += this.jsxReadEntity();\n          chunkStart = this.state.pos;\n        } else if (isNewLine(ch)) {\n          out += this.input.slice(chunkStart, this.state.pos);\n          out += this.jsxReadNewLine(false);\n          chunkStart = this.state.pos;\n        } else {\n          ++this.state.pos;\n        }\n      }\n      out += this.input.slice(chunkStart, this.state.pos++);\n      this.finishToken(tt.string, out);\n    }\n\n    jsxReadEntity(): string {\n      const startPos = ++this.state.pos;\n      if (this.codePointAtPos(this.state.pos) === charCodes.numberSign) {\n        ++this.state.pos;\n\n        let radix = 10;\n        if (this.codePointAtPos(this.state.pos) === charCodes.lowercaseX) {\n          radix = 16;\n          ++this.state.pos;\n        }\n\n        const codePoint = this.readInt(\n          radix,\n          /* len */ undefined,\n          /* forceLen */ false,\n          /* allowNumSeparator */ \"bail\",\n        );\n        if (\n          codePoint !== null &&\n          this.codePointAtPos(this.state.pos) === charCodes.semicolon\n        ) {\n          ++this.state.pos;\n          return String.fromCodePoint(codePoint);\n        }\n      } else {\n        let count = 0;\n        let semi = false;\n        while (\n          count++ < 10 &&\n          this.state.pos < this.length &&\n          !(semi = this.codePointAtPos(this.state.pos) == charCodes.semicolon)\n        ) {\n          ++this.state.pos;\n        }\n\n        if (semi) {\n          const desc = this.input.slice(startPos, this.state.pos);\n          const entity = XHTMLEntities[desc];\n          ++this.state.pos;\n\n          if (entity) {\n            return entity;\n          }\n        }\n      }\n\n      // Not a valid entity\n      this.state.pos = startPos;\n      return \"&\";\n    }\n\n    // Read a JSX identifier (valid tag or attribute name).\n    //\n    // Optimized version since JSX identifiers can\"t contain\n    // escape characters and so can be read as single slice.\n    // Also assumes that first character was already checked\n    // by isIdentifierStart in readToken.\n\n    jsxReadWord(): void {\n      let ch;\n      const start = this.state.pos;\n      do {\n        ch = this.input.charCodeAt(++this.state.pos);\n      } while (isIdentifierChar(ch) || ch === charCodes.dash);\n      this.finishToken(tt.jsxName, this.input.slice(start, this.state.pos));\n    }\n\n    // Parse next token as JSX identifier\n\n    jsxParseIdentifier(): N.JSXIdentifier {\n      const node = this.startNode();\n      if (this.match(tt.jsxName)) {\n        node.name = this.state.value;\n      } else if (tokenIsKeyword(this.state.type)) {\n        node.name = tokenLabelName(this.state.type);\n      } else {\n        this.unexpected();\n      }\n      this.next();\n      return this.finishNode(node, \"JSXIdentifier\");\n    }\n\n    // Parse namespaced identifier.\n\n    jsxParseNamespacedName(): N.JSXNamespacedName {\n      const startLoc = this.state.startLoc;\n      const name = this.jsxParseIdentifier();\n      if (!this.eat(tt.colon)) return name;\n\n      const node = this.startNodeAt(startLoc);\n      node.namespace = name;\n      node.name = this.jsxParseIdentifier();\n      return this.finishNode(node, \"JSXNamespacedName\");\n    }\n\n    // Parses element name in any form - namespaced, member\n    // or single identifier.\n\n    jsxParseElementName():\n      | N.JSXIdentifier\n      | N.JSXNamespacedName\n      | N.JSXMemberExpression {\n      const startLoc = this.state.startLoc;\n      let node = this.jsxParseNamespacedName();\n      if (node.type === \"JSXNamespacedName\") {\n        return node;\n      }\n      while (this.eat(tt.dot)) {\n        const newNode = this.startNodeAt(startLoc);\n        newNode.object = node;\n        newNode.property = this.jsxParseIdentifier();\n        node = this.finishNode(newNode, \"JSXMemberExpression\");\n      }\n      return node;\n    }\n\n    // Parses any type of JSX attribute value.\n\n    jsxParseAttributeValue(): N.Expression {\n      let node;\n      switch (this.state.type) {\n        case tt.braceL:\n          node = this.startNode();\n          this.setContext(tc.brace);\n          this.next();\n          node = this.jsxParseExpressionContainer(node, tc.j_oTag);\n          if (node.expression.type === \"JSXEmptyExpression\") {\n            this.raise(JsxErrors.AttributeIsEmpty, { at: node });\n          }\n          return node;\n\n        case tt.jsxTagStart:\n        case tt.string:\n          return this.parseExprAtom();\n\n        default:\n          throw this.raise(JsxErrors.UnsupportedJsxValue, {\n            at: this.state.startLoc,\n          });\n      }\n    }\n\n    // JSXEmptyExpression is unique type since it doesn't actually parse anything,\n    // and so it should start at the end of last read token (left brace) and finish\n    // at the beginning of the next one (right brace).\n\n    jsxParseEmptyExpression(): N.JSXEmptyExpression {\n      const node = this.startNodeAt(this.state.lastTokEndLoc);\n      return this.finishNodeAt(node, \"JSXEmptyExpression\", this.state.startLoc);\n    }\n\n    // Parse JSX spread child\n\n    jsxParseSpreadChild(node: Undone<N.JSXSpreadChild>): N.JSXSpreadChild {\n      this.next(); // ellipsis\n      node.expression = this.parseExpression();\n      this.setContext(tc.j_expr);\n      this.state.canStartJSXElement = true;\n      this.expect(tt.braceR);\n\n      return this.finishNode(node, \"JSXSpreadChild\");\n    }\n\n    // Parses JSX expression enclosed into curly brackets.\n\n    jsxParseExpressionContainer(\n      node: Undone<N.JSXExpressionContainer>,\n      previousContext: TokContext,\n    ): N.JSXExpressionContainer {\n      if (this.match(tt.braceR)) {\n        node.expression = this.jsxParseEmptyExpression();\n      } else {\n        const expression = this.parseExpression();\n\n        if (process.env.BABEL_8_BREAKING) {\n          if (\n            expression.type === \"SequenceExpression\" &&\n            !expression.extra?.parenthesized\n          ) {\n            this.raise(JsxErrors.UnexpectedSequenceExpression, {\n              at: expression.expressions[1],\n            });\n          }\n        }\n\n        node.expression = expression;\n      }\n      this.setContext(previousContext);\n      this.state.canStartJSXElement = true;\n      this.expect(tt.braceR);\n\n      return this.finishNode(node, \"JSXExpressionContainer\");\n    }\n\n    // Parses following JSX attribute name-value pair.\n\n    jsxParseAttribute(): N.JSXAttribute {\n      const node = this.startNode();\n      if (this.match(tt.braceL)) {\n        this.setContext(tc.brace);\n        this.next();\n        this.expect(tt.ellipsis);\n        node.argument = this.parseMaybeAssignAllowIn();\n        this.setContext(tc.j_oTag);\n        this.state.canStartJSXElement = true;\n        this.expect(tt.braceR);\n        return this.finishNode(node, \"JSXSpreadAttribute\");\n      }\n      node.name = this.jsxParseNamespacedName();\n      node.value = this.eat(tt.eq) ? this.jsxParseAttributeValue() : null;\n      return this.finishNode(node, \"JSXAttribute\");\n    }\n\n    // Parses JSX opening tag starting after \"<\".\n\n    jsxParseOpeningElementAt(startLoc: Position): N.JSXOpeningElement {\n      const node = this.startNodeAt<N.JSXOpeningElement | N.JSXOpeningFragment>(\n        startLoc,\n      );\n      if (this.eat(tt.jsxTagEnd)) {\n        // @ts-expect-error migrate to Babel types\n        return this.finishNode(node, \"JSXOpeningFragment\");\n      }\n      node.name = this.jsxParseElementName();\n      return this.jsxParseOpeningElementAfterName(\n        node as Undone<N.JSXOpeningElement>,\n      );\n    }\n\n    jsxParseOpeningElementAfterName(\n      node: Undone<N.JSXOpeningElement>,\n    ): N.JSXOpeningElement {\n      const attributes: N.JSXAttribute[] = [];\n      while (!this.match(tt.slash) && !this.match(tt.jsxTagEnd)) {\n        attributes.push(this.jsxParseAttribute());\n      }\n      node.attributes = attributes;\n      node.selfClosing = this.eat(tt.slash);\n      this.expect(tt.jsxTagEnd);\n      return this.finishNode(node, \"JSXOpeningElement\");\n    }\n\n    // Parses JSX closing tag starting after \"</\".\n\n    jsxParseClosingElementAt(startLoc: Position): N.JSXClosingElement {\n      const node = this.startNodeAt(startLoc);\n      if (this.eat(tt.jsxTagEnd)) {\n        return this.finishNode(node, \"JSXClosingFragment\");\n      }\n      node.name = this.jsxParseElementName();\n      this.expect(tt.jsxTagEnd);\n      return this.finishNode(node, \"JSXClosingElement\");\n    }\n\n    // Parses entire JSX element, including it\"s opening tag\n    // (starting after \"<\"), attributes, contents and closing tag.\n\n    jsxParseElementAt(startLoc: Position): N.JSXElement {\n      const node = this.startNodeAt(startLoc);\n      const children = [];\n      const openingElement = this.jsxParseOpeningElementAt(startLoc);\n      let closingElement = null;\n\n      if (!openingElement.selfClosing) {\n        contents: for (;;) {\n          switch (this.state.type) {\n            case tt.jsxTagStart:\n              startLoc = this.state.startLoc;\n              this.next();\n              if (this.eat(tt.slash)) {\n                closingElement = this.jsxParseClosingElementAt(startLoc);\n                break contents;\n              }\n              children.push(this.jsxParseElementAt(startLoc));\n              break;\n\n            case tt.jsxText:\n              children.push(this.parseExprAtom());\n              break;\n\n            case tt.braceL: {\n              const node = this.startNode<\n                N.JSXSpreadChild | N.JSXExpressionContainer\n              >();\n              this.setContext(tc.brace);\n              this.next();\n              if (this.match(tt.ellipsis)) {\n                children.push(this.jsxParseSpreadChild(node));\n              } else {\n                children.push(\n                  this.jsxParseExpressionContainer(node, tc.j_expr),\n                );\n              }\n\n              break;\n            }\n            // istanbul ignore next - should never happen\n            default:\n              this.unexpected();\n          }\n        }\n\n        if (\n          isFragment(openingElement) &&\n          !isFragment(closingElement) &&\n          closingElement !== null\n        ) {\n          this.raise(JsxErrors.MissingClosingTagFragment, {\n            at: closingElement,\n          });\n        } else if (!isFragment(openingElement) && isFragment(closingElement)) {\n          this.raise(JsxErrors.MissingClosingTagElement, {\n            at: closingElement,\n            openingTagName: getQualifiedJSXName(openingElement.name),\n          });\n        } else if (!isFragment(openingElement) && !isFragment(closingElement)) {\n          if (\n            getQualifiedJSXName(closingElement.name) !==\n            getQualifiedJSXName(openingElement.name)\n          ) {\n            this.raise(JsxErrors.MissingClosingTagElement, {\n              at: closingElement,\n              openingTagName: getQualifiedJSXName(openingElement.name),\n            });\n          }\n        }\n      }\n\n      if (isFragment(openingElement)) {\n        node.openingFragment = openingElement;\n        node.closingFragment = closingElement;\n      } else {\n        node.openingElement = openingElement;\n        node.closingElement = closingElement;\n      }\n      node.children = children;\n      if (this.match(tt.lt)) {\n        throw this.raise(JsxErrors.UnwrappedAdjacentJSXElements, {\n          at: this.state.startLoc,\n        });\n      }\n\n      return isFragment(openingElement)\n        ? this.finishNode(node, \"JSXFragment\")\n        : this.finishNode(node, \"JSXElement\");\n    }\n\n    // Parses entire JSX element from current position.\n\n    jsxParseElement(): N.JSXElement {\n      const startLoc = this.state.startLoc;\n      this.next();\n      return this.jsxParseElementAt(startLoc);\n    }\n\n    setContext(newContext: TokContext) {\n      const { context } = this.state;\n      context[context.length - 1] = newContext;\n    }\n\n    // ==================================\n    // Overrides\n    // ==================================\n\n    parseExprAtom(refExpressionErrors?: ExpressionErrors | null): N.Expression {\n      if (this.match(tt.jsxText)) {\n        return this.parseLiteral(this.state.value, \"JSXText\");\n      } else if (this.match(tt.jsxTagStart)) {\n        return this.jsxParseElement();\n      } else if (\n        this.match(tt.lt) &&\n        this.input.charCodeAt(this.state.pos) !== charCodes.exclamationMark\n      ) {\n        // In case we encounter an lt token here it will always be the start of\n        // jsx as the lt sign is not allowed in places that expect an expression\n        this.replaceToken(tt.jsxTagStart);\n        return this.jsxParseElement();\n      } else {\n        return super.parseExprAtom(refExpressionErrors);\n      }\n    }\n\n    skipSpace() {\n      const curContext = this.curContext();\n      if (!curContext.preserveSpace) super.skipSpace();\n    }\n\n    getTokenFromCode(code: number): void {\n      const context = this.curContext();\n\n      if (context === tc.j_expr) {\n        this.jsxReadToken();\n        return;\n      }\n\n      if (context === tc.j_oTag || context === tc.j_cTag) {\n        if (isIdentifierStart(code)) {\n          this.jsxReadWord();\n          return;\n        }\n\n        if (code === charCodes.greaterThan) {\n          ++this.state.pos;\n          this.finishToken(tt.jsxTagEnd);\n          return;\n        }\n\n        if (\n          (code === charCodes.quotationMark || code === charCodes.apostrophe) &&\n          context === tc.j_oTag\n        ) {\n          this.jsxReadString(code);\n          return;\n        }\n      }\n\n      if (\n        code === charCodes.lessThan &&\n        this.state.canStartJSXElement &&\n        this.input.charCodeAt(this.state.pos + 1) !== charCodes.exclamationMark\n      ) {\n        ++this.state.pos;\n        this.finishToken(tt.jsxTagStart);\n        return;\n      }\n\n      super.getTokenFromCode(code);\n    }\n\n    updateContext(prevType: TokenType): void {\n      const { context, type } = this.state;\n      if (type === tt.slash && prevType === tt.jsxTagStart) {\n        // do not consider JSX expr -> JSX open tag -> ... anymore\n        // reconsider as closing tag context\n        context.splice(-2, 2, tc.j_cTag);\n        this.state.canStartJSXElement = false;\n      } else if (type === tt.jsxTagStart) {\n        // start opening tag context\n        context.push(tc.j_oTag);\n      } else if (type === tt.jsxTagEnd) {\n        const out = context[context.length - 1];\n        if ((out === tc.j_oTag && prevType === tt.slash) || out === tc.j_cTag) {\n          context.pop();\n          this.state.canStartJSXElement =\n            context[context.length - 1] === tc.j_expr;\n        } else {\n          this.setContext(tc.j_expr);\n          this.state.canStartJSXElement = true;\n        }\n      } else {\n        this.state.canStartJSXElement = tokenComesBeforeExpression(type);\n      }\n    }\n  };\n","import type { Position } from \"../../util/location\";\nimport ScopeHandler, { Scope } from \"../../util/scope\";\nimport {\n  BIND_KIND_TYPE,\n  BIND_FLAGS_TS_ENUM,\n  BIND_FLAGS_TS_CONST_ENUM,\n  BIND_FLAGS_TS_EXPORT_ONLY,\n  BIND_KIND_VALUE,\n  BIND_FLAGS_CLASS,\n  type ScopeFlags,\n  type BindingTypes,\n  BIND_FLAGS_TS_IMPORT,\n  SCOPE_TS_MODULE,\n} from \"../../util/scopeflags\";\nimport type * as N from \"../../types\";\nimport { Errors } from \"../../parse-error\";\n\nclass TypeScriptScope extends Scope {\n  types: Set<string> = new Set();\n\n  // enums (which are also in .types)\n  enums: Set<string> = new Set();\n\n  // const enums (which are also in .enums and .types)\n  constEnums: Set<string> = new Set();\n\n  // classes (which are also in .lexical) and interface (which are also in .types)\n  classes: Set<string> = new Set();\n\n  // namespaces and ambient functions (or classes) are too difficult to track,\n  // especially without type analysis.\n  // We need to track them anyway, to avoid \"X is not defined\" errors\n  // when exporting them.\n  exportOnlyBindings: Set<string> = new Set();\n}\n\n// See https://github.com/babel/babel/pull/9766#discussion_r268920730 for an\n// explanation of how typescript handles scope.\n\nexport default class TypeScriptScopeHandler extends ScopeHandler<TypeScriptScope> {\n  importsStack: Set<string>[] = [];\n\n  createScope(flags: ScopeFlags): TypeScriptScope {\n    this.importsStack.push(new Set()); // Always keep the top-level scope for export checks.\n\n    return new TypeScriptScope(flags);\n  }\n\n  enter(flags: number): void {\n    if (flags == SCOPE_TS_MODULE) {\n      this.importsStack.push(new Set());\n    }\n\n    super.enter(flags);\n  }\n\n  exit() {\n    const flags = super.exit();\n\n    if (flags == SCOPE_TS_MODULE) {\n      this.importsStack.pop();\n    }\n\n    return flags;\n  }\n\n  hasImport(name: string, allowShadow?: boolean) {\n    const len = this.importsStack.length;\n    if (this.importsStack[len - 1].has(name)) {\n      return true;\n    }\n    if (!allowShadow && len > 1) {\n      for (let i = 0; i < len - 1; i++) {\n        if (this.importsStack[i].has(name)) return true;\n      }\n    }\n    return false;\n  }\n\n  declareName(name: string, bindingType: BindingTypes, loc: Position) {\n    if (bindingType & BIND_FLAGS_TS_IMPORT) {\n      if (this.hasImport(name, true)) {\n        this.parser.raise(Errors.VarRedeclaration, {\n          at: loc,\n          identifierName: name,\n        });\n      }\n      this.importsStack[this.importsStack.length - 1].add(name);\n      return;\n    }\n\n    const scope = this.currentScope();\n    if (bindingType & BIND_FLAGS_TS_EXPORT_ONLY) {\n      this.maybeExportDefined(scope, name);\n      scope.exportOnlyBindings.add(name);\n      return;\n    }\n\n    super.declareName(name, bindingType, loc);\n\n    if (bindingType & BIND_KIND_TYPE) {\n      if (!(bindingType & BIND_KIND_VALUE)) {\n        // \"Value\" bindings have already been registered by the superclass.\n        this.checkRedeclarationInScope(scope, name, bindingType, loc);\n        this.maybeExportDefined(scope, name);\n      }\n      scope.types.add(name);\n    }\n    if (bindingType & BIND_FLAGS_TS_ENUM) scope.enums.add(name);\n    if (bindingType & BIND_FLAGS_TS_CONST_ENUM) scope.constEnums.add(name);\n    if (bindingType & BIND_FLAGS_CLASS) scope.classes.add(name);\n  }\n\n  isRedeclaredInScope(\n    scope: TypeScriptScope,\n    name: string,\n    bindingType: BindingTypes,\n  ): boolean {\n    if (scope.enums.has(name)) {\n      if (bindingType & BIND_FLAGS_TS_ENUM) {\n        // Enums can be merged with other enums if they are both\n        //  const or both non-const.\n        const isConst = !!(bindingType & BIND_FLAGS_TS_CONST_ENUM);\n        const wasConst = scope.constEnums.has(name);\n        return isConst !== wasConst;\n      }\n      return true;\n    }\n    if (bindingType & BIND_FLAGS_CLASS && scope.classes.has(name)) {\n      if (scope.lexical.has(name)) {\n        // Classes can be merged with interfaces\n        return !!(bindingType & BIND_KIND_VALUE);\n      } else {\n        // Interface can be merged with other classes or interfaces\n        return false;\n      }\n    }\n    if (bindingType & BIND_KIND_TYPE && scope.types.has(name)) {\n      return true;\n    }\n\n    return super.isRedeclaredInScope(scope, name, bindingType);\n  }\n\n  checkLocalExport(id: N.Identifier) {\n    const { name } = id;\n\n    if (this.hasImport(name)) return;\n\n    const len = this.scopeStack.length;\n    for (let i = len - 1; i >= 0; i--) {\n      const scope = this.scopeStack[i];\n      if (scope.types.has(name) || scope.exportOnlyBindings.has(name)) return;\n    }\n\n    super.checkLocalExport(id);\n  }\n}\n","import * as charCodes from \"charcodes\";\nimport { tt, type TokenType } from \"../tokenizer/types\";\nimport type {\n  AssignmentPattern,\n  TSParameterProperty,\n  Decorator,\n  Expression,\n  Identifier,\n  Node,\n  Pattern,\n  RestElement,\n  SpreadElement,\n  ObjectOrClassMember,\n  ClassMember,\n  ObjectMember,\n  TsNamedTypeElementBase,\n  PrivateName,\n  ObjectExpression,\n  ObjectPattern,\n  ArrayExpression,\n  ArrayPattern,\n} from \"../types\";\nimport type { Pos, Position } from \"../util/location\";\nimport {\n  isStrictBindOnlyReservedWord,\n  isStrictBindReservedWord,\n} from \"../util/identifier\";\nimport { NodeUtils, type Undone } from \"./node\";\nimport {\n  type BindingTypes,\n  BIND_NONE,\n  BIND_FLAGS_NO_LET_IN_LEXICAL,\n} from \"../util/scopeflags\";\nimport type { ExpressionErrors } from \"./util\";\nimport { Errors, type LValAncestor } from \"../parse-error\";\nimport type Parser from \"./index\";\n\nconst getOwn = <T extends {}>(object: T, key: keyof T) =>\n  Object.hasOwnProperty.call(object, key) && object[key];\n\nconst unwrapParenthesizedExpression = (node: Node): Node => {\n  return node.type === \"ParenthesizedExpression\"\n    ? unwrapParenthesizedExpression(node.expression)\n    : node;\n};\n\nexport const enum ParseBindingListFlags {\n  ALLOW_EMPTY = 1 << 0,\n  IS_FUNCTION_PARAMS = 1 << 1,\n  IS_CONSTRUCTOR_PARAMS = 1 << 2,\n}\n\nexport default abstract class LValParser extends NodeUtils {\n  // Forward-declaration: defined in expression.js\n  abstract parseIdentifier(liberal?: boolean): Identifier;\n  abstract parseMaybeAssign(\n    refExpressionErrors?: ExpressionErrors | null,\n    afterLeftParse?: Function,\n    refNeedsArrowPos?: Pos | null,\n  ): Expression;\n\n  abstract parseMaybeAssignAllowIn(\n    refExpressionErrors?: ExpressionErrors | null,\n    afterLeftParse?: Function,\n    refNeedsArrowPos?: Pos | null,\n  ): Expression;\n\n  abstract parseObjectLike<T extends ObjectPattern | ObjectExpression>(\n    close: TokenType,\n    isPattern: boolean,\n    isRecord?: boolean,\n    refExpressionErrors?: ExpressionErrors,\n  ): T;\n  abstract parseObjPropValue(\n    prop: any,\n    startLoc: Position | null,\n    isGenerator: boolean,\n    isAsync: boolean,\n    isPattern: boolean,\n    isAccessor: boolean,\n    refExpressionErrors?: ExpressionErrors | null,\n  ): void;\n  abstract parsePropertyName(\n    prop: ObjectOrClassMember | ClassMember | TsNamedTypeElementBase,\n  ): Expression | Identifier;\n  abstract parsePrivateName(): PrivateName;\n  // Forward-declaration: defined in statement.js\n  abstract parseDecorator(): Decorator;\n\n  /**\n   * Convert existing expression atom to assignable pattern\n   * if possible. Also checks invalid destructuring targets:\n   *\n   * - Parenthesized Destructuring patterns\n   * - RestElement is not the last element\n   * - Missing `=` in assignment pattern\n   *\n   * NOTE: There is a corresponding \"isAssignable\" method.\n   * When this one is updated, please check if also that one needs to be updated.\n   *\n   * @param node The expression atom\n   * @param isLHS Whether we are parsing a LeftHandSideExpression.\n   *              If isLHS is `true`, the following cases are allowed: `[(a)] = [0]`, `[(a.b)] = [0]`\n   *              If isLHS is `false`, we are in an arrow function parameters list.\n   */\n  toAssignable(node: Node, isLHS: boolean = false): void {\n    let parenthesized = undefined;\n    if (node.type === \"ParenthesizedExpression\" || node.extra?.parenthesized) {\n      parenthesized = unwrapParenthesizedExpression(node);\n      if (isLHS) {\n        // an LHS can be reinterpreted to a binding pattern but not vice versa.\n        // therefore a parenthesized identifier is ambiguous until we are sure it is an assignment expression\n        // i.e. `([(a) = []] = []) => {}`\n        // see also `recordArrowParameterBindingError` signature in packages/babel-parser/src/util/expression-scope.js\n        if (parenthesized.type === \"Identifier\") {\n          this.expressionScope.recordArrowParameterBindingError(\n            Errors.InvalidParenthesizedAssignment,\n            { at: node },\n          );\n        } else if (parenthesized.type !== \"MemberExpression\") {\n          // A parenthesized member expression can be in LHS but not in pattern.\n          // If the LHS is later interpreted as a pattern, `checkLVal` will throw for member expression binding\n          // i.e. `([(a.b) = []] = []) => {}`\n          this.raise(Errors.InvalidParenthesizedAssignment, { at: node });\n        }\n      } else {\n        this.raise(Errors.InvalidParenthesizedAssignment, { at: node });\n      }\n    }\n\n    switch (node.type) {\n      case \"Identifier\":\n      case \"ObjectPattern\":\n      case \"ArrayPattern\":\n      case \"AssignmentPattern\":\n      case \"RestElement\":\n        break;\n\n      case \"ObjectExpression\":\n        node.type = \"ObjectPattern\";\n        for (\n          let i = 0, length = node.properties.length, last = length - 1;\n          i < length;\n          i++\n        ) {\n          const prop = node.properties[i];\n          const isLast = i === last;\n          this.toAssignableObjectExpressionProp(prop, isLast, isLHS);\n\n          if (\n            isLast &&\n            prop.type === \"RestElement\" &&\n            node.extra?.trailingCommaLoc\n          ) {\n            this.raise(Errors.RestTrailingComma, {\n              at: node.extra.trailingCommaLoc,\n            });\n          }\n        }\n        break;\n\n      case \"ObjectProperty\": {\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        break;\n      }\n\n      case \"SpreadElement\": {\n        throw new Error(\n          \"Internal @babel/parser error (this is a bug, please report it).\" +\n            \" SpreadElement should be converted by .toAssignable's caller.\",\n        );\n      }\n\n      case \"ArrayExpression\":\n        node.type = \"ArrayPattern\";\n        this.toAssignableList(\n          node.elements,\n          node.extra?.trailingCommaLoc,\n          isLHS,\n        );\n        break;\n\n      case \"AssignmentExpression\":\n        if (node.operator !== \"=\") {\n          this.raise(Errors.MissingEqInAssignment, { at: node.left.loc.end });\n        }\n\n        node.type = \"AssignmentPattern\";\n        delete node.operator;\n        this.toAssignable(node.left, isLHS);\n        break;\n\n      case \"ParenthesizedExpression\":\n        /*::invariant (parenthesized !== undefined) */\n        this.toAssignable(parenthesized, isLHS);\n        break;\n\n      default:\n      // We don't know how to deal with this node. It will\n      // be reported by a later call to checkLVal\n    }\n  }\n\n  toAssignableObjectExpressionProp(\n    prop: Node,\n    isLast: boolean,\n    isLHS: boolean,\n  ) {\n    if (prop.type === \"ObjectMethod\") {\n      this.raise(\n        prop.kind === \"get\" || prop.kind === \"set\"\n          ? Errors.PatternHasAccessor\n          : Errors.PatternHasMethod,\n        { at: prop.key },\n      );\n    } else if (prop.type === \"SpreadElement\") {\n      prop.type = \"RestElement\";\n      const arg = prop.argument;\n      this.checkToRestConversion(arg, /* allowPattern */ false);\n      this.toAssignable(arg, isLHS);\n\n      if (!isLast) {\n        this.raise(Errors.RestTrailingComma, { at: prop });\n      }\n    } else {\n      this.toAssignable(prop, isLHS);\n    }\n  }\n\n  // Convert list of expression atoms to binding list.\n\n  toAssignableList(\n    exprList: Expression[],\n    trailingCommaLoc: Position | undefined | null,\n    isLHS: boolean,\n  ): void {\n    const end = exprList.length - 1;\n\n    for (let i = 0; i <= end; i++) {\n      const elt = exprList[i];\n      if (!elt) continue;\n\n      if (elt.type === \"SpreadElement\") {\n        elt.type = \"RestElement\";\n        const arg = elt.argument;\n        this.checkToRestConversion(arg, /* allowPattern */ true);\n        this.toAssignable(arg, isLHS);\n      } else {\n        this.toAssignable(elt, isLHS);\n      }\n\n      if (elt.type === \"RestElement\") {\n        if (i < end) {\n          this.raise(Errors.RestTrailingComma, { at: elt });\n        } else if (trailingCommaLoc) {\n          this.raise(Errors.RestTrailingComma, { at: trailingCommaLoc });\n        }\n      }\n    }\n  }\n\n  isAssignable(node: Node, isBinding?: boolean): boolean {\n    switch (node.type) {\n      case \"Identifier\":\n      case \"ObjectPattern\":\n      case \"ArrayPattern\":\n      case \"AssignmentPattern\":\n      case \"RestElement\":\n        return true;\n\n      case \"ObjectExpression\": {\n        const last = node.properties.length - 1;\n        return (node.properties as ObjectExpression[\"properties\"]).every(\n          (prop, i) => {\n            return (\n              prop.type !== \"ObjectMethod\" &&\n              (i === last || prop.type !== \"SpreadElement\") &&\n              this.isAssignable(prop)\n            );\n          },\n        );\n      }\n\n      case \"ObjectProperty\":\n        return this.isAssignable(node.value);\n\n      case \"SpreadElement\":\n        return this.isAssignable(node.argument);\n\n      case \"ArrayExpression\":\n        return (node as ArrayExpression).elements.every(\n          element => element === null || this.isAssignable(element),\n        );\n\n      case \"AssignmentExpression\":\n        return node.operator === \"=\";\n\n      case \"ParenthesizedExpression\":\n        return this.isAssignable(node.expression);\n\n      case \"MemberExpression\":\n      case \"OptionalMemberExpression\":\n        return !isBinding;\n\n      default:\n        return false;\n    }\n  }\n\n  // Convert list of expression atoms to a list of\n\n  toReferencedList(\n    exprList: ReadonlyArray<Expression | undefined | null>,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    isParenthesizedExpr?: boolean,\n  ): ReadonlyArray<Expression | undefined | null> {\n    return exprList;\n  }\n\n  toReferencedListDeep(\n    exprList: ReadonlyArray<Expression | undefined | null>,\n    isParenthesizedExpr?: boolean,\n  ): void {\n    this.toReferencedList(exprList, isParenthesizedExpr);\n\n    for (const expr of exprList) {\n      if (expr?.type === \"ArrayExpression\") {\n        this.toReferencedListDeep(expr.elements);\n      }\n    }\n  }\n\n  // Parses spread element.\n\n  parseSpread(\n    this: Parser,\n    refExpressionErrors?: ExpressionErrors | null,\n  ): SpreadElement {\n    const node = this.startNode<SpreadElement>();\n    this.next();\n    node.argument = this.parseMaybeAssignAllowIn(\n      refExpressionErrors,\n      undefined,\n    );\n    return this.finishNode(node, \"SpreadElement\");\n  }\n\n  // https://tc39.es/ecma262/#prod-BindingRestProperty\n  // https://tc39.es/ecma262/#prod-BindingRestElement\n  parseRestBinding(this: Parser): RestElement {\n    const node = this.startNode<RestElement>();\n    this.next(); // eat `...`\n    node.argument = this.parseBindingAtom();\n    return this.finishNode(node, \"RestElement\");\n  }\n\n  // Parses lvalue (assignable) atom.\n  parseBindingAtom(this: Parser): Pattern {\n    // https://tc39.es/ecma262/#prod-BindingPattern\n    switch (this.state.type) {\n      case tt.bracketL: {\n        const node = this.startNode<ArrayPattern>();\n        this.next();\n        // @ts-expect-error: Fixme: TSParameterProperty can not be assigned to node.elements\n        node.elements = this.parseBindingList(\n          tt.bracketR,\n          charCodes.rightSquareBracket,\n          ParseBindingListFlags.ALLOW_EMPTY,\n        );\n        return this.finishNode(node, \"ArrayPattern\");\n      }\n\n      case tt.braceL:\n        return this.parseObjectLike(tt.braceR, true);\n    }\n\n    // https://tc39.es/ecma262/#prod-BindingIdentifier\n    return this.parseIdentifier();\n  }\n\n  // https://tc39.es/ecma262/#prod-BindingElementList\n  parseBindingList(\n    this: Parser,\n    close: TokenType,\n    closeCharCode: (typeof charCodes)[keyof typeof charCodes],\n    flags: ParseBindingListFlags,\n  ): Array<Pattern | TSParameterProperty> {\n    const allowEmpty = flags & ParseBindingListFlags.ALLOW_EMPTY;\n\n    const elts: Array<Pattern | TSParameterProperty> = [];\n    let first = true;\n    while (!this.eat(close)) {\n      if (first) {\n        first = false;\n      } else {\n        this.expect(tt.comma);\n      }\n      if (allowEmpty && this.match(tt.comma)) {\n        elts.push(null);\n      } else if (this.eat(close)) {\n        break;\n      } else if (this.match(tt.ellipsis)) {\n        elts.push(\n          this.parseAssignableListItemTypes(this.parseRestBinding(), flags),\n        );\n        if (!this.checkCommaAfterRest(closeCharCode)) {\n          this.expect(close);\n          break;\n        }\n      } else {\n        const decorators = [];\n        if (this.match(tt.at) && this.hasPlugin(\"decorators\")) {\n          this.raise(Errors.UnsupportedParameterDecorator, {\n            at: this.state.startLoc,\n          });\n        }\n        // invariant: hasPlugin(\"decorators-legacy\")\n        while (this.match(tt.at)) {\n          decorators.push(this.parseDecorator());\n        }\n        elts.push(this.parseAssignableListItem(flags, decorators));\n      }\n    }\n    return elts;\n  }\n\n  // https://tc39.es/ecma262/#prod-BindingRestProperty\n  parseBindingRestProperty(\n    this: Parser,\n    prop: Undone<RestElement>,\n  ): RestElement {\n    this.next(); // eat '...'\n    // Don't use parseRestBinding() as we only allow Identifier here.\n    prop.argument = this.parseIdentifier();\n    this.checkCommaAfterRest(charCodes.rightCurlyBrace);\n    return this.finishNode(prop, \"RestElement\");\n  }\n\n  // https://tc39.es/ecma262/#prod-BindingProperty\n  parseBindingProperty(this: Parser): ObjectMember | RestElement {\n    const prop = this.startNode<ObjectMember | RestElement>();\n    const { type, startLoc } = this.state;\n    if (type === tt.ellipsis) {\n      return this.parseBindingRestProperty(prop as Undone<RestElement>);\n    } else if (type === tt.privateName) {\n      this.expectPlugin(\"destructuringPrivate\", startLoc);\n      this.classScope.usePrivateName(this.state.value, startLoc);\n      (prop as Undone<ObjectMember>).key = this.parsePrivateName();\n    } else {\n      this.parsePropertyName(prop as Undone<ObjectMember>);\n    }\n    (prop as Undone<ObjectMember>).method = false;\n    return this.parseObjPropValue(\n      prop as Undone<ObjectMember>,\n      startLoc,\n      false /* isGenerator */,\n      false /* isAsync */,\n      true /* isPattern */,\n      false /* isAccessor */,\n    );\n  }\n\n  parseAssignableListItem(\n    this: Parser,\n    flags: ParseBindingListFlags,\n    decorators: Decorator[],\n  ): Pattern | TSParameterProperty {\n    const left = this.parseMaybeDefault();\n    this.parseAssignableListItemTypes(left, flags);\n    const elt = this.parseMaybeDefault(left.loc.start, left);\n    if (decorators.length) {\n      left.decorators = decorators;\n    }\n    return elt;\n  }\n\n  // Used by flow/typescript plugin to add type annotations to binding elements\n  parseAssignableListItemTypes(\n    param: Pattern,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    flags: ParseBindingListFlags,\n  ): Pattern {\n    return param;\n  }\n\n  // Parses assignment pattern around given atom if possible.\n  // https://tc39.es/ecma262/#prod-BindingElement\n  parseMaybeDefault(\n    this: Parser,\n    startLoc?: Position | null,\n    left?: Pattern | null,\n  ): Pattern {\n    startLoc ??= this.state.startLoc;\n    left = left ?? this.parseBindingAtom();\n    if (!this.eat(tt.eq)) return left;\n\n    const node = this.startNodeAt<AssignmentPattern>(startLoc);\n    node.left = left;\n    node.right = this.parseMaybeAssignAllowIn();\n    return this.finishNode(node, \"AssignmentPattern\");\n  }\n  /**\n   * Return information use in determining whether a Node of a given type is an LVal,\n   * possibly given certain additional context information.\n   *\n   * Subclasser notes: This method has kind of a lot of mixed, but related,\n   * responsibilities. If we can definitively determine with the information\n   * provided that this either *is* or *isn't* a valid `LVal`, then the return\n   * value is easy: just return `true` or `false`. However, if it is a valid\n   * LVal *ancestor*, and thus its descendants must be subsequently visited to\n   * continue the \"investigation\", then this method should return the relevant\n   * child key as a `string`. In some special cases, you additionally want to\n   * convey that this node should be treated as if it were parenthesized. In\n   * that case, a tuple of [key: string, parenthesized: boolean] is returned.\n   * The `string`-only return option is actually just a shorthand for:\n   * `[key: string, parenthesized: false]`.\n   *\n   * @param type A Node `type` string\n   * @param isUnparenthesizedInAssign\n   *        Whether the node in question is unparenthesized and its parent\n   *        is either an assignment pattern or an assignment expression.\n   * @param binding\n   *        The binding operation that is being considered for this potential\n   *        LVal.\n   * @returns `true` or `false` if we can immediately determine whether the node\n   *          type in question can be treated as an `LVal`.\n   *          A `string` key to traverse if we must check this child.\n   *          A `[string, boolean]` tuple if we need to check this child and\n   *          treat is as parenthesized.\n   */\n  isValidLVal(\n    type: string,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    isUnparenthesizedInAssign: boolean,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    binding: BindingTypes,\n  ): string | boolean {\n    return getOwn(\n      {\n        AssignmentPattern: \"left\",\n        RestElement: \"argument\",\n        ObjectProperty: \"value\",\n        ParenthesizedExpression: \"expression\",\n        ArrayPattern: \"elements\",\n        ObjectPattern: \"properties\",\n      },\n      // @ts-expect-error refine string to enum\n      type,\n    );\n  }\n\n  /**\n   * Verify that a target expression is an lval (something that can be assigned to).\n   *\n   * @param expression The expression in question to check.\n   * @param options A set of options described below.\n   * @param options.in\n   *        The relevant ancestor to provide context information for the error\n   *        if the check fails.\n   * @param options.binding\n   *        The desired binding type. If the given expression is an identifier\n   *        and `binding` is not `BIND_NONE`, `checkLVal` will register binding\n   *        to the parser scope See also `src/util/scopeflags.js`\n   * @param options.checkClashes\n   *        An optional string set to check if an identifier name is included.\n   *        `checkLVal` will add checked identifier name to `checkClashes` It is\n   *        used in tracking duplicates in function parameter lists. If it is\n   *        false, `checkLVal` will skip duplicate checks\n   * @param options.strictModeChanged\n   *        Whether an identifier has been parsed in a sloppy context but should\n   *        be reinterpreted as strict-mode. e.g. `(arguments) => { \"use strict \"}`\n   * @param options.hasParenthesizedAncestor\n   *        This is only used internally during recursive calls, and you should\n   *        not have to set it yourself.\n   */\n\n  checkLVal(\n    expression: Expression | ObjectMember | RestElement,\n    {\n      in: ancestor,\n      binding = BIND_NONE,\n      checkClashes = false,\n      strictModeChanged = false,\n      hasParenthesizedAncestor = false,\n    }: {\n      in: LValAncestor;\n      binding?: BindingTypes;\n      checkClashes?: Set<string> | false;\n      strictModeChanged?: boolean;\n      hasParenthesizedAncestor?: boolean;\n    },\n  ): void {\n    const type = expression.type;\n\n    // If we find here an ObjectMethod, it's because this was originally\n    // an ObjectExpression which has then been converted.\n    // toAssignable already reported this error with a nicer message.\n    if (this.isObjectMethod(expression)) return;\n\n    if (type === \"MemberExpression\") {\n      if (binding !== BIND_NONE) {\n        this.raise(Errors.InvalidPropertyBindingPattern, { at: expression });\n      }\n      return;\n    }\n\n    if (type === \"Identifier\") {\n      this.checkIdentifier(\n        expression as Identifier,\n        binding,\n        strictModeChanged,\n      );\n\n      const { name } = expression as Identifier;\n\n      if (checkClashes) {\n        if (checkClashes.has(name)) {\n          this.raise(Errors.ParamDupe, { at: expression });\n        } else {\n          checkClashes.add(name);\n        }\n      }\n\n      return;\n    }\n\n    const validity = this.isValidLVal(\n      type,\n      !(hasParenthesizedAncestor || expression.extra?.parenthesized) &&\n        ancestor.type === \"AssignmentExpression\",\n      binding,\n    );\n\n    if (validity === true) return;\n    if (validity === false) {\n      const ParseErrorClass =\n        binding === BIND_NONE ? Errors.InvalidLhs : Errors.InvalidLhsBinding;\n\n      this.raise(ParseErrorClass, { at: expression, ancestor });\n      return;\n    }\n\n    const [key, isParenthesizedExpression] = Array.isArray(validity)\n      ? validity\n      : [validity, type === \"ParenthesizedExpression\"];\n    const nextAncestor =\n      type === \"ArrayPattern\" ||\n      type === \"ObjectPattern\" ||\n      type === \"ParenthesizedExpression\"\n        ? ({ type } as const)\n        : ancestor;\n\n    // @ts-expect-error key may not index expression.\n    for (const child of [].concat(expression[key])) {\n      if (child) {\n        this.checkLVal(child, {\n          in: nextAncestor,\n          binding,\n          checkClashes,\n          strictModeChanged,\n          hasParenthesizedAncestor: isParenthesizedExpression,\n        });\n      }\n    }\n  }\n\n  checkIdentifier(\n    at: Identifier,\n    bindingType: BindingTypes,\n    strictModeChanged: boolean = false,\n  ) {\n    if (\n      this.state.strict &&\n      (strictModeChanged\n        ? isStrictBindReservedWord(at.name, this.inModule)\n        : isStrictBindOnlyReservedWord(at.name))\n    ) {\n      if (bindingType === BIND_NONE) {\n        this.raise(Errors.StrictEvalArguments, { at, referenceName: at.name });\n      } else {\n        this.raise(Errors.StrictEvalArgumentsBinding, {\n          at,\n          bindingName: at.name,\n        });\n      }\n    }\n\n    if (bindingType & BIND_FLAGS_NO_LET_IN_LEXICAL && at.name === \"let\") {\n      this.raise(Errors.LetInLexicalBinding, { at });\n    }\n\n    if (!(bindingType & BIND_NONE)) {\n      this.declareNameFromIdentifier(at, bindingType);\n    }\n  }\n\n  declareNameFromIdentifier(identifier: Identifier, binding: BindingTypes) {\n    this.scope.declareName(identifier.name, binding, identifier.loc.start);\n  }\n\n  checkToRestConversion(node: Node, allowPattern: boolean): void {\n    switch (node.type) {\n      case \"ParenthesizedExpression\":\n        this.checkToRestConversion(node.expression, allowPattern);\n        break;\n      case \"Identifier\":\n      case \"MemberExpression\":\n        break;\n      case \"ArrayExpression\":\n      case \"ObjectExpression\":\n        if (allowPattern) break;\n      /* falls through */\n      default:\n        this.raise(Errors.InvalidRestAssignmentPattern, { at: node });\n    }\n  }\n\n  checkCommaAfterRest(\n    close: (typeof charCodes)[keyof typeof charCodes],\n  ): boolean {\n    if (!this.match(tt.comma)) {\n      return false;\n    }\n\n    this.raise(\n      this.lookaheadCharCode() === close\n        ? Errors.RestTrailingComma\n        : Errors.ElementAfterRest,\n      { at: this.state.startLoc },\n    );\n\n    return true;\n  }\n}\n","/*:: declare var invariant; */\n\nimport type State from \"../../tokenizer/state\";\nimport {\n  tokenIsIdentifier,\n  tokenIsTSDeclarationStart,\n  tokenIsTSTypeOperator,\n  tokenOperatorPrecedence,\n  tokenIsKeywordOrIdentifier,\n  tt,\n  type TokenType,\n  tokenIsTemplate,\n  tokenCanStartExpression,\n} from \"../../tokenizer/types\";\nimport { types as tc } from \"../../tokenizer/context\";\nimport type * as N from \"../../types\";\nimport type { Position } from \"../../util/location\";\nimport { createPositionWithColumnOffset } from \"../../util/location\";\nimport type Parser from \"../../parser\";\nimport {\n  type BindingTypes,\n  SCOPE_TS_MODULE,\n  SCOPE_OTHER,\n  BIND_TS_ENUM,\n  BIND_TS_CONST_ENUM,\n  BIND_TS_TYPE,\n  BIND_TS_INTERFACE,\n  BIND_TS_AMBIENT,\n  BIND_TS_NAMESPACE,\n  BIND_TS_TYPE_IMPORT,\n  BIND_CLASS,\n  BIND_NONE,\n  BIND_FLAGS_TS_IMPORT,\n} from \"../../util/scopeflags\";\nimport TypeScriptScopeHandler from \"./scope\";\nimport * as charCodes from \"charcodes\";\nimport type { ExpressionErrors } from \"../../parser/util\";\nimport type { ParseStatementFlag } from \"../../parser/statement\";\nimport { PARAM } from \"../../util/production-parameter\";\nimport { Errors, ParseErrorEnum } from \"../../parse-error\";\nimport { cloneIdentifier, type Undone } from \"../../parser/node\";\nimport type { Pattern } from \"../../types\";\nimport type { Expression } from \"../../types\";\nimport type { IJSXParserMixin } from \"../jsx\";\nimport { ParseBindingListFlags } from \"../../parser/lval\";\n\nconst getOwn = <T extends {}>(object: T, key: keyof T) =>\n  Object.hasOwnProperty.call(object, key) && object[key];\n\ntype TsModifier =\n  | \"readonly\"\n  | \"abstract\"\n  | \"declare\"\n  | \"static\"\n  | \"override\"\n  | \"const\"\n  | N.Accessibility\n  | N.VarianceAnnotations;\n\nfunction nonNull<T>(x?: T | null): T {\n  if (x == null) {\n    throw new Error(`Unexpected ${x} value.`);\n  }\n  return x;\n}\n\nfunction assert(x: boolean): void {\n  if (!x) {\n    throw new Error(\"Assert fail\");\n  }\n}\n\ntype ParsingContext =\n  | \"EnumMembers\"\n  | \"HeritageClauseElement\"\n  | \"TupleElementTypes\"\n  | \"TypeMembers\"\n  | \"TypeParametersOrArguments\";\n\ntype ModifierBase = {\n  accessibility?: N.Accessibility;\n} & {\n  [key in TsModifier]?: boolean | undefined | null;\n};\n\n/* eslint sort-keys: \"error\" */\nconst TSErrors = ParseErrorEnum`typescript`({\n  AbstractMethodHasImplementation: ({ methodName }: { methodName: string }) =>\n    `Method '${methodName}' cannot have an implementation because it is marked abstract.`,\n  AbstractPropertyHasInitializer: ({\n    propertyName,\n  }: {\n    propertyName: string;\n  }) =>\n    `Property '${propertyName}' cannot have an initializer because it is marked abstract.`,\n  AccesorCannotDeclareThisParameter:\n    \"'get' and 'set' accessors cannot declare 'this' parameters.\",\n  AccesorCannotHaveTypeParameters: \"An accessor cannot have type parameters.\",\n  AccessorCannotBeOptional:\n    \"An 'accessor' property cannot be declared optional.\",\n  ClassMethodHasDeclare: \"Class methods cannot have the 'declare' modifier.\",\n  ClassMethodHasReadonly: \"Class methods cannot have the 'readonly' modifier.\",\n  ConstInitiailizerMustBeStringOrNumericLiteralOrLiteralEnumReference:\n    \"A 'const' initializer in an ambient context must be a string or numeric literal or literal enum reference.\",\n  ConstructorHasTypeParameters:\n    \"Type parameters cannot appear on a constructor declaration.\",\n  DeclareAccessor: ({ kind }: { kind: \"get\" | \"set\" }) =>\n    `'declare' is not allowed in ${kind}ters.`,\n  DeclareClassFieldHasInitializer:\n    \"Initializers are not allowed in ambient contexts.\",\n  DeclareFunctionHasImplementation:\n    \"An implementation cannot be declared in ambient contexts.\",\n  DuplicateAccessibilityModifier:\n    // `Accessibility modifier already seen: ${modifier}` would be more helpful.\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    ({ modifier }: { modifier: N.Accessibility }) =>\n      `Accessibility modifier already seen.`,\n  DuplicateModifier: ({ modifier }: { modifier: TsModifier }) =>\n    `Duplicate modifier: '${modifier}'.`,\n  // `token` matches the terminology used by typescript:\n  // https://github.com/microsoft/TypeScript/blob/main/src/compiler/types.ts#L2915\n  EmptyHeritageClauseType: ({ token }: { token: \"extends\" | \"implements\" }) =>\n    `'${token}' list cannot be empty.`,\n  EmptyTypeArguments: \"Type argument list cannot be empty.\",\n  EmptyTypeParameters: \"Type parameter list cannot be empty.\",\n  ExpectedAmbientAfterExportDeclare:\n    \"'export declare' must be followed by an ambient declaration.\",\n  ImportAliasHasImportType: \"An import alias can not use 'import type'.\",\n  ImportReflectionHasImportType:\n    \"An `import module` declaration can not use `type` modifier\",\n  IncompatibleModifiers: ({\n    modifiers,\n  }: {\n    modifiers: [TsModifier, TsModifier];\n  }) =>\n    `'${modifiers[0]}' modifier cannot be used with '${modifiers[1]}' modifier.`,\n  IndexSignatureHasAbstract:\n    \"Index signatures cannot have the 'abstract' modifier.\",\n  IndexSignatureHasAccessibility: ({\n    modifier,\n  }: {\n    modifier: N.Accessibility;\n  }) =>\n    `Index signatures cannot have an accessibility modifier ('${modifier}').`,\n  IndexSignatureHasDeclare:\n    \"Index signatures cannot have the 'declare' modifier.\",\n  IndexSignatureHasOverride:\n    \"'override' modifier cannot appear on an index signature.\",\n  IndexSignatureHasStatic:\n    \"Index signatures cannot have the 'static' modifier.\",\n  InitializerNotAllowedInAmbientContext:\n    \"Initializers are not allowed in ambient contexts.\",\n  InvalidModifierOnTypeMember: ({ modifier }: { modifier: TsModifier }) =>\n    `'${modifier}' modifier cannot appear on a type member.`,\n  InvalidModifierOnTypeParameter: ({ modifier }: { modifier: TsModifier }) =>\n    `'${modifier}' modifier cannot appear on a type parameter.`,\n  InvalidModifierOnTypeParameterPositions: ({\n    modifier,\n  }: {\n    modifier: TsModifier;\n  }) =>\n    `'${modifier}' modifier can only appear on a type parameter of a class, interface or type alias.`,\n  InvalidModifiersOrder: ({\n    orderedModifiers,\n  }: {\n    orderedModifiers: [TsModifier, TsModifier];\n  }) =>\n    `'${orderedModifiers[0]}' modifier must precede '${orderedModifiers[1]}' modifier.`,\n  InvalidPropertyAccessAfterInstantiationExpression:\n    \"Invalid property access after an instantiation expression. \" +\n    \"You can either wrap the instantiation expression in parentheses, or delete the type arguments.\",\n  InvalidTupleMemberLabel:\n    \"Tuple members must be labeled with a simple identifier.\",\n  MissingInterfaceName:\n    \"'interface' declarations must be followed by an identifier.\",\n  MixedLabeledAndUnlabeledElements:\n    \"Tuple members must all have names or all not have names.\",\n  NonAbstractClassHasAbstractMethod:\n    \"Abstract methods can only appear within an abstract class.\",\n  NonClassMethodPropertyHasAbstractModifer:\n    \"'abstract' modifier can only appear on a class, method, or property declaration.\",\n  OptionalTypeBeforeRequired:\n    \"A required element cannot follow an optional element.\",\n  OverrideNotInSubClass:\n    \"This member cannot have an 'override' modifier because its containing class does not extend another class.\",\n  PatternIsOptional:\n    \"A binding pattern parameter cannot be optional in an implementation signature.\",\n  PrivateElementHasAbstract:\n    \"Private elements cannot have the 'abstract' modifier.\",\n  PrivateElementHasAccessibility: ({\n    modifier,\n  }: {\n    modifier: N.Accessibility;\n  }) =>\n    `Private elements cannot have an accessibility modifier ('${modifier}').`,\n  ReadonlyForMethodSignature:\n    \"'readonly' modifier can only appear on a property declaration or index signature.\",\n  ReservedArrowTypeParam:\n    \"This syntax is reserved in files with the .mts or .cts extension. Add a trailing comma, as in `<T,>() => ...`.\",\n  ReservedTypeAssertion:\n    \"This syntax is reserved in files with the .mts or .cts extension. Use an `as` expression instead.\",\n  // TODO: Accesor -> Accessor\n  SetAccesorCannotHaveOptionalParameter:\n    \"A 'set' accessor cannot have an optional parameter.\",\n  SetAccesorCannotHaveRestParameter:\n    \"A 'set' accessor cannot have rest parameter.\",\n  SetAccesorCannotHaveReturnType:\n    \"A 'set' accessor cannot have a return type annotation.\",\n  SingleTypeParameterWithoutTrailingComma: ({\n    typeParameterName,\n  }: {\n    typeParameterName: string;\n  }) =>\n    `Single type parameter ${typeParameterName} should have a trailing comma. Example usage: <${typeParameterName},>.`,\n  StaticBlockCannotHaveModifier:\n    \"Static class blocks cannot have any modifier.\",\n  TupleOptionalAfterType:\n    \"A labeled tuple optional element must be declared using a question mark after the name and before the colon (`name?: type`), rather than after the type (`name: type?`).\",\n  TypeAnnotationAfterAssign:\n    \"Type annotations must come before default assignments, e.g. instead of `age = 25: number` use `age: number = 25`.\",\n  TypeImportCannotSpecifyDefaultAndNamed:\n    \"A type-only import can specify a default import or named bindings, but not both.\",\n  TypeModifierIsUsedInTypeExports:\n    \"The 'type' modifier cannot be used on a named export when 'export type' is used on its export statement.\",\n  TypeModifierIsUsedInTypeImports:\n    \"The 'type' modifier cannot be used on a named import when 'import type' is used on its import statement.\",\n  UnexpectedParameterModifier:\n    \"A parameter property is only allowed in a constructor implementation.\",\n  UnexpectedReadonly:\n    \"'readonly' type modifier is only permitted on array and tuple literal types.\",\n  UnexpectedTypeAnnotation: \"Did not expect a type annotation here.\",\n  UnexpectedTypeCastInParameter: \"Unexpected type cast in parameter position.\",\n  UnsupportedImportTypeArgument:\n    \"Argument in a type import must be a string literal.\",\n  UnsupportedParameterPropertyKind:\n    \"A parameter property may not be declared using a binding pattern.\",\n  UnsupportedSignatureParameterKind: ({ type }: { type: string }) =>\n    `Name in a signature must be an Identifier, ObjectPattern or ArrayPattern, instead got ${type}.`,\n});\n\n/* eslint-disable sort-keys */\n\n// Doesn't handle \"void\" or \"null\" because those are keywords, not identifiers.\n// It also doesn't handle \"intrinsic\", since usually it's not a keyword.\nfunction keywordTypeFromName(value: string): N.TsKeywordTypeType | undefined {\n  switch (value) {\n    case \"any\":\n      return \"TSAnyKeyword\";\n    case \"boolean\":\n      return \"TSBooleanKeyword\";\n    case \"bigint\":\n      return \"TSBigIntKeyword\";\n    case \"never\":\n      return \"TSNeverKeyword\";\n    case \"number\":\n      return \"TSNumberKeyword\";\n    case \"object\":\n      return \"TSObjectKeyword\";\n    case \"string\":\n      return \"TSStringKeyword\";\n    case \"symbol\":\n      return \"TSSymbolKeyword\";\n    case \"undefined\":\n      return \"TSUndefinedKeyword\";\n    case \"unknown\":\n      return \"TSUnknownKeyword\";\n    default:\n      return undefined;\n  }\n}\n\nfunction tsIsAccessModifier(modifier: string): modifier is N.Accessibility {\n  return (\n    modifier === \"private\" || modifier === \"public\" || modifier === \"protected\"\n  );\n}\n\nfunction tsIsVarianceAnnotations(\n  modifier: string,\n): modifier is N.VarianceAnnotations {\n  return modifier === \"in\" || modifier === \"out\";\n}\n\ntype ClassWithMixin<\n  T extends new (...args: any) => any,\n  M extends object,\n> = T extends new (...args: infer P) => infer I\n  ? new (...args: P) => I & M\n  : never;\n\nexport default (superClass: ClassWithMixin<typeof Parser, IJSXParserMixin>) =>\n  class TypeScriptParserMixin extends superClass implements Parser {\n    getScopeHandler(): {\n      new (...args: any): TypeScriptScopeHandler;\n    } {\n      return TypeScriptScopeHandler;\n    }\n\n    tsIsIdentifier(): boolean {\n      // TODO: actually a bit more complex in TypeScript, but shouldn't matter.\n      // See https://github.com/Microsoft/TypeScript/issues/15008\n      return tokenIsIdentifier(this.state.type);\n    }\n\n    tsTokenCanFollowModifier() {\n      return (\n        (this.match(tt.bracketL) ||\n          this.match(tt.braceL) ||\n          this.match(tt.star) ||\n          this.match(tt.ellipsis) ||\n          this.match(tt.privateName) ||\n          this.isLiteralPropertyName()) &&\n        !this.hasPrecedingLineBreak()\n      );\n    }\n\n    tsNextTokenCanFollowModifier() {\n      // Note: TypeScript's implementation is much more complicated because\n      // more things are considered modifiers there.\n      // This implementation only handles modifiers not handled by @babel/parser itself. And \"static\".\n      // TODO: Would be nice to avoid lookahead. Want a hasLineBreakUpNext() method...\n      this.next();\n      return this.tsTokenCanFollowModifier();\n    }\n\n    /** Parses a modifier matching one the given modifier names. */\n    tsParseModifier<T extends TsModifier>(\n      allowedModifiers: T[],\n      stopOnStartOfClassStaticBlock?: boolean,\n    ): T | undefined | null {\n      if (\n        !tokenIsIdentifier(this.state.type) &&\n        this.state.type !== tt._in &&\n        this.state.type !== tt._const\n      ) {\n        return undefined;\n      }\n\n      const modifier = this.state.value;\n      if (allowedModifiers.indexOf(modifier) !== -1) {\n        if (stopOnStartOfClassStaticBlock && this.tsIsStartOfStaticBlocks()) {\n          return undefined;\n        }\n        if (this.tsTryParse(this.tsNextTokenCanFollowModifier.bind(this))) {\n          return modifier;\n        }\n      }\n      return undefined;\n    }\n\n    /** Parses a list of modifiers, in any order.\n     *  If you need a specific order, you must call this function multiple times:\n     *    this.tsParseModifiers({ modified: node, allowedModifiers: [\"public\"] });\n     *    this.tsParseModifiers({ modified: node, allowedModifiers: [\"abstract\", \"readonly\"] });\n     */\n    tsParseModifiers<N extends ModifierBase>(\n      {\n        allowedModifiers,\n        disallowedModifiers,\n        stopOnStartOfClassStaticBlock,\n        errorTemplate = TSErrors.InvalidModifierOnTypeMember,\n      }: {\n        allowedModifiers: readonly TsModifier[];\n        disallowedModifiers?: TsModifier[];\n        stopOnStartOfClassStaticBlock?: boolean;\n        errorTemplate?: typeof TSErrors.InvalidModifierOnTypeMember;\n      },\n      modified: N,\n    ): void {\n      const enforceOrder = (\n        loc: Position,\n        modifier: TsModifier,\n        before: TsModifier,\n        after: TsModifier,\n      ) => {\n        if (modifier === before && modified[after]) {\n          this.raise(TSErrors.InvalidModifiersOrder, {\n            at: loc,\n            orderedModifiers: [before, after],\n          });\n        }\n      };\n      const incompatible = (\n        loc: Position,\n        modifier: TsModifier,\n        mod1: TsModifier,\n        mod2: TsModifier,\n      ) => {\n        if (\n          (modified[mod1] && modifier === mod2) ||\n          (modified[mod2] && modifier === mod1)\n        ) {\n          this.raise(TSErrors.IncompatibleModifiers, {\n            at: loc,\n            modifiers: [mod1, mod2],\n          });\n        }\n      };\n\n      for (;;) {\n        const { startLoc } = this.state;\n        const modifier: TsModifier | undefined | null = this.tsParseModifier(\n          allowedModifiers.concat(disallowedModifiers ?? []),\n          stopOnStartOfClassStaticBlock,\n        );\n\n        if (!modifier) break;\n\n        if (tsIsAccessModifier(modifier)) {\n          if (modified.accessibility) {\n            this.raise(TSErrors.DuplicateAccessibilityModifier, {\n              at: startLoc,\n              modifier,\n            });\n          } else {\n            enforceOrder(startLoc, modifier, modifier, \"override\");\n            enforceOrder(startLoc, modifier, modifier, \"static\");\n            enforceOrder(startLoc, modifier, modifier, \"readonly\");\n\n            modified.accessibility = modifier;\n          }\n        } else if (tsIsVarianceAnnotations(modifier)) {\n          if (modified[modifier]) {\n            this.raise(TSErrors.DuplicateModifier, { at: startLoc, modifier });\n          }\n          modified[modifier] = true;\n\n          enforceOrder(startLoc, modifier, \"in\", \"out\");\n        } else {\n          if (Object.hasOwnProperty.call(modified, modifier)) {\n            this.raise(TSErrors.DuplicateModifier, { at: startLoc, modifier });\n          } else {\n            enforceOrder(startLoc, modifier, \"static\", \"readonly\");\n            enforceOrder(startLoc, modifier, \"static\", \"override\");\n            enforceOrder(startLoc, modifier, \"override\", \"readonly\");\n            enforceOrder(startLoc, modifier, \"abstract\", \"override\");\n\n            incompatible(startLoc, modifier, \"declare\", \"override\");\n            incompatible(startLoc, modifier, \"static\", \"abstract\");\n          }\n          modified[modifier] = true;\n        }\n\n        if (disallowedModifiers?.includes(modifier)) {\n          this.raise(errorTemplate, {\n            at: startLoc,\n            modifier,\n          });\n        }\n      }\n    }\n\n    tsIsListTerminator(kind: ParsingContext): boolean {\n      switch (kind) {\n        case \"EnumMembers\":\n        case \"TypeMembers\":\n          return this.match(tt.braceR);\n        case \"HeritageClauseElement\":\n          return this.match(tt.braceL);\n        case \"TupleElementTypes\":\n          return this.match(tt.bracketR);\n        case \"TypeParametersOrArguments\":\n          return this.match(tt.gt);\n      }\n    }\n\n    tsParseList<T extends N.Node>(\n      kind: ParsingContext,\n      parseElement: () => T,\n    ): T[] {\n      const result: T[] = [];\n      while (!this.tsIsListTerminator(kind)) {\n        // Skipping \"parseListElement\" from the TS source since that's just for error handling.\n        result.push(parseElement());\n      }\n      return result;\n    }\n\n    tsParseDelimitedList<T extends N.Node>(\n      kind: ParsingContext,\n      parseElement: () => T,\n      refTrailingCommaPos?: {\n        value: number;\n      },\n    ): T[] {\n      return nonNull(\n        this.tsParseDelimitedListWorker(\n          kind,\n          parseElement,\n          /* expectSuccess */ true,\n          refTrailingCommaPos,\n        ),\n      );\n    }\n\n    /**\n     * If !expectSuccess, returns undefined instead of failing to parse.\n     * If expectSuccess, parseElement should always return a defined value.\n     */\n    tsParseDelimitedListWorker<T extends N.Node>(\n      kind: ParsingContext,\n      parseElement: () => T | undefined | null,\n      expectSuccess: boolean,\n      refTrailingCommaPos?: {\n        value: number;\n      },\n    ): T[] | undefined | null {\n      const result = [];\n      let trailingCommaPos = -1;\n\n      for (;;) {\n        if (this.tsIsListTerminator(kind)) {\n          break;\n        }\n        trailingCommaPos = -1;\n\n        const element = parseElement();\n        if (element == null) {\n          return undefined;\n        }\n        result.push(element);\n\n        if (this.eat(tt.comma)) {\n          trailingCommaPos = this.state.lastTokStart;\n          continue;\n        }\n\n        if (this.tsIsListTerminator(kind)) {\n          break;\n        }\n\n        if (expectSuccess) {\n          // This will fail with an error about a missing comma\n          this.expect(tt.comma);\n        }\n        return undefined;\n      }\n\n      if (refTrailingCommaPos) {\n        refTrailingCommaPos.value = trailingCommaPos;\n      }\n\n      return result;\n    }\n\n    tsParseBracketedList<T extends N.Node>(\n      kind: ParsingContext,\n      parseElement: () => T,\n      bracket: boolean,\n      skipFirstToken: boolean,\n      refTrailingCommaPos?: {\n        value: number;\n      },\n    ): T[] {\n      if (!skipFirstToken) {\n        if (bracket) {\n          this.expect(tt.bracketL);\n        } else {\n          this.expect(tt.lt);\n        }\n      }\n\n      const result = this.tsParseDelimitedList(\n        kind,\n        parseElement,\n        refTrailingCommaPos,\n      );\n\n      if (bracket) {\n        this.expect(tt.bracketR);\n      } else {\n        this.expect(tt.gt);\n      }\n\n      return result;\n    }\n\n    tsParseImportType(): N.TsImportType {\n      const node = this.startNode<N.TsImportType>();\n      this.expect(tt._import);\n      this.expect(tt.parenL);\n      if (!this.match(tt.string)) {\n        this.raise(TSErrors.UnsupportedImportTypeArgument, {\n          at: this.state.startLoc,\n        });\n      }\n\n      // For compatibility to estree we cannot call parseLiteral directly here\n      node.argument = super.parseExprAtom() as N.StringLiteral;\n      this.expect(tt.parenR);\n\n      if (this.eat(tt.dot)) {\n        // In this instance, the entity name will actually itself be a\n        // qualifier, so allow it to be a reserved word as well.\n        node.qualifier = this.tsParseEntityName();\n      }\n      if (this.match(tt.lt)) {\n        node.typeParameters = this.tsParseTypeArguments();\n      }\n      return this.finishNode(node, \"TSImportType\");\n    }\n\n    tsParseEntityName(allowReservedWords: boolean = true): N.TsEntityName {\n      let entity: N.TsEntityName = this.parseIdentifier(allowReservedWords);\n      while (this.eat(tt.dot)) {\n        const node: Undone<N.TsQualifiedName> =\n          this.startNodeAtNode<N.TsQualifiedName>(entity);\n        node.left = entity;\n        node.right = this.parseIdentifier(allowReservedWords);\n        entity = this.finishNode(node, \"TSQualifiedName\");\n      }\n      return entity;\n    }\n\n    tsParseTypeReference(): N.TsTypeReference {\n      const node = this.startNode<N.TsTypeReference>();\n      node.typeName = this.tsParseEntityName();\n      if (!this.hasPrecedingLineBreak() && this.match(tt.lt)) {\n        node.typeParameters = this.tsParseTypeArguments();\n      }\n      return this.finishNode(node, \"TSTypeReference\");\n    }\n\n    tsParseThisTypePredicate(lhs: N.TsThisType): N.TsTypePredicate {\n      this.next();\n      const node = this.startNodeAtNode<N.TsTypePredicate>(lhs);\n      node.parameterName = lhs;\n      node.typeAnnotation = this.tsParseTypeAnnotation(/* eatColon */ false);\n      node.asserts = false;\n      return this.finishNode(node, \"TSTypePredicate\");\n    }\n\n    tsParseThisTypeNode(): N.TsThisType {\n      const node = this.startNode<N.TsThisType>();\n      this.next();\n      return this.finishNode(node, \"TSThisType\");\n    }\n\n    tsParseTypeQuery(): N.TsTypeQuery {\n      const node = this.startNode<N.TsTypeQuery>();\n      this.expect(tt._typeof);\n      if (this.match(tt._import)) {\n        node.exprName = this.tsParseImportType();\n      } else {\n        node.exprName = this.tsParseEntityName();\n      }\n      if (!this.hasPrecedingLineBreak() && this.match(tt.lt)) {\n        node.typeParameters = this.tsParseTypeArguments();\n      }\n      return this.finishNode(node, \"TSTypeQuery\");\n    }\n\n    tsParseInOutModifiers = this.tsParseModifiers.bind(this, {\n      allowedModifiers: [\"in\", \"out\"],\n      disallowedModifiers: [\n        \"const\",\n        \"public\",\n        \"private\",\n        \"protected\",\n        \"readonly\",\n        \"declare\",\n        \"abstract\",\n        \"override\",\n      ],\n      errorTemplate: TSErrors.InvalidModifierOnTypeParameter,\n    });\n\n    tsParseConstModifier = this.tsParseModifiers.bind(this, {\n      allowedModifiers: [\"const\"],\n      // for better error recovery\n      disallowedModifiers: [\"in\", \"out\"],\n      errorTemplate: TSErrors.InvalidModifierOnTypeParameterPositions,\n    });\n\n    tsParseInOutConstModifiers = this.tsParseModifiers.bind(this, {\n      allowedModifiers: [\"in\", \"out\", \"const\"],\n      disallowedModifiers: [\n        \"public\",\n        \"private\",\n        \"protected\",\n        \"readonly\",\n        \"declare\",\n        \"abstract\",\n        \"override\",\n      ],\n      errorTemplate: TSErrors.InvalidModifierOnTypeParameter,\n    });\n\n    tsParseTypeParameter(\n      parseModifiers: (node: Undone<N.TsTypeParameter>) => void,\n    ): N.TsTypeParameter {\n      const node = this.startNode<N.TsTypeParameter>();\n\n      parseModifiers(node);\n\n      node.name = this.tsParseTypeParameterName();\n      node.constraint = this.tsEatThenParseType(tt._extends);\n      node.default = this.tsEatThenParseType(tt.eq);\n      return this.finishNode(node, \"TSTypeParameter\");\n    }\n\n    tsTryParseTypeParameters(\n      parseModifiers: (node: N.TsTypeParameter) => void,\n    ): N.TsTypeParameterDeclaration | undefined | null {\n      if (this.match(tt.lt)) {\n        return this.tsParseTypeParameters(parseModifiers);\n      }\n    }\n\n    tsParseTypeParameters(parseModifiers: (node: N.TsTypeParameter) => void) {\n      const node = this.startNode<N.TsTypeParameterDeclaration>();\n\n      if (this.match(tt.lt) || this.match(tt.jsxTagStart)) {\n        this.next();\n      } else {\n        this.unexpected();\n      }\n\n      const refTrailingCommaPos = { value: -1 };\n\n      node.params = this.tsParseBracketedList(\n        \"TypeParametersOrArguments\",\n        // @ts-expect-error refine typings\n        this.tsParseTypeParameter.bind(this, parseModifiers),\n        /* bracket */ false,\n        /* skipFirstToken */ true,\n        refTrailingCommaPos,\n      );\n      if (node.params.length === 0) {\n        this.raise(TSErrors.EmptyTypeParameters, { at: node });\n      }\n      if (refTrailingCommaPos.value !== -1) {\n        this.addExtra(node, \"trailingComma\", refTrailingCommaPos.value);\n      }\n      return this.finishNode(node, \"TSTypeParameterDeclaration\");\n    }\n\n    // Note: In TypeScript implementation we must provide `yieldContext` and `awaitContext`,\n    // but here it's always false, because this is only used for types.\n    tsFillSignature(\n      returnToken: TokenType,\n      signature: Undone<N.TsSignatureDeclaration>,\n    ): void {\n      // Arrow fns *must* have return token (`=>`). Normal functions can omit it.\n      const returnTokenRequired = returnToken === tt.arrow;\n\n      // https://github.com/babel/babel/issues/9231\n      const paramsKey = process.env.BABEL_8_BREAKING ? \"params\" : \"parameters\";\n      const returnTypeKey = process.env.BABEL_8_BREAKING\n        ? \"returnType\"\n        : \"typeAnnotation\";\n\n      signature.typeParameters = this.tsTryParseTypeParameters(\n        this.tsParseConstModifier,\n      );\n      this.expect(tt.parenL);\n      signature[paramsKey] = this.tsParseBindingListForSignature();\n      if (returnTokenRequired) {\n        signature[returnTypeKey] =\n          this.tsParseTypeOrTypePredicateAnnotation(returnToken);\n      } else if (this.match(returnToken)) {\n        signature[returnTypeKey] =\n          this.tsParseTypeOrTypePredicateAnnotation(returnToken);\n      }\n    }\n\n    tsParseBindingListForSignature(): Array<\n      N.Identifier | N.RestElement | N.ObjectPattern | N.ArrayPattern\n    > {\n      const list = super.parseBindingList(\n        tt.parenR,\n        charCodes.rightParenthesis,\n        ParseBindingListFlags.IS_FUNCTION_PARAMS,\n      );\n      for (const pattern of list) {\n        const { type } = pattern;\n        if (type === \"AssignmentPattern\" || type === \"TSParameterProperty\") {\n          this.raise(TSErrors.UnsupportedSignatureParameterKind, {\n            at: pattern,\n            type,\n          });\n        }\n      }\n      return list as Exclude<\n        (typeof list)[0],\n        N.AssignmentPattern | N.TSParameterProperty\n      >[];\n    }\n\n    tsParseTypeMemberSemicolon(): void {\n      if (!this.eat(tt.comma) && !this.isLineTerminator()) {\n        this.expect(tt.semi);\n      }\n    }\n\n    tsParseSignatureMember(\n      kind: \"TSCallSignatureDeclaration\" | \"TSConstructSignatureDeclaration\",\n      node: Undone<\n        N.TsCallSignatureDeclaration | N.TsConstructSignatureDeclaration\n      >,\n    ): N.TsCallSignatureDeclaration | N.TsConstructSignatureDeclaration {\n      this.tsFillSignature(tt.colon, node);\n      this.tsParseTypeMemberSemicolon();\n      return this.finishNode(node, kind);\n    }\n\n    tsIsUnambiguouslyIndexSignature() {\n      this.next(); // Skip '{'\n      if (tokenIsIdentifier(this.state.type)) {\n        this.next();\n        return this.match(tt.colon);\n      }\n      return false;\n    }\n\n    tsTryParseIndexSignature(\n      node: Undone<N.TsIndexSignature>,\n    ): N.TsIndexSignature | undefined {\n      if (\n        !(\n          this.match(tt.bracketL) &&\n          this.tsLookAhead(this.tsIsUnambiguouslyIndexSignature.bind(this))\n        )\n      ) {\n        return;\n      }\n\n      this.expect(tt.bracketL);\n      const id = this.parseIdentifier();\n      id.typeAnnotation = this.tsParseTypeAnnotation();\n      this.resetEndLocation(id); // set end position to end of type\n\n      this.expect(tt.bracketR);\n      node.parameters = [id];\n\n      const type = this.tsTryParseTypeAnnotation();\n      if (type) node.typeAnnotation = type;\n      this.tsParseTypeMemberSemicolon();\n      return this.finishNode(node, \"TSIndexSignature\");\n    }\n\n    tsParsePropertyOrMethodSignature(\n      node: N.TsPropertySignature | N.TsMethodSignature,\n      readonly: boolean,\n    ): N.TsPropertySignature | N.TsMethodSignature {\n      if (this.eat(tt.question)) node.optional = true;\n      const nodeAny: any = node;\n\n      if (this.match(tt.parenL) || this.match(tt.lt)) {\n        if (readonly) {\n          this.raise(TSErrors.ReadonlyForMethodSignature, { at: node });\n        }\n        const method: N.TsMethodSignature = nodeAny;\n        if (method.kind && this.match(tt.lt)) {\n          this.raise(TSErrors.AccesorCannotHaveTypeParameters, {\n            at: this.state.curPosition(),\n          });\n        }\n        this.tsFillSignature(tt.colon, method);\n        this.tsParseTypeMemberSemicolon();\n        const paramsKey = process.env.BABEL_8_BREAKING\n          ? \"params\"\n          : \"parameters\";\n        const returnTypeKey = process.env.BABEL_8_BREAKING\n          ? \"returnType\"\n          : \"typeAnnotation\";\n        if (method.kind === \"get\") {\n          if (method[paramsKey].length > 0) {\n            this.raise(Errors.BadGetterArity, { at: this.state.curPosition() });\n            if (this.isThisParam(method[paramsKey][0])) {\n              this.raise(TSErrors.AccesorCannotDeclareThisParameter, {\n                at: this.state.curPosition(),\n              });\n            }\n          }\n        } else if (method.kind === \"set\") {\n          if (method[paramsKey].length !== 1) {\n            this.raise(Errors.BadSetterArity, { at: this.state.curPosition() });\n          } else {\n            const firstParameter = method[paramsKey][0];\n            if (this.isThisParam(firstParameter)) {\n              this.raise(TSErrors.AccesorCannotDeclareThisParameter, {\n                at: this.state.curPosition(),\n              });\n            }\n            if (\n              firstParameter.type === \"Identifier\" &&\n              firstParameter.optional\n            ) {\n              this.raise(TSErrors.SetAccesorCannotHaveOptionalParameter, {\n                at: this.state.curPosition(),\n              });\n            }\n            if (firstParameter.type === \"RestElement\") {\n              this.raise(TSErrors.SetAccesorCannotHaveRestParameter, {\n                at: this.state.curPosition(),\n              });\n            }\n          }\n          if (method[returnTypeKey]) {\n            this.raise(TSErrors.SetAccesorCannotHaveReturnType, {\n              at: method[returnTypeKey],\n            });\n          }\n        } else {\n          method.kind = \"method\";\n        }\n        return this.finishNode(method, \"TSMethodSignature\");\n      } else {\n        const property: N.TsPropertySignature = nodeAny;\n        if (readonly) property.readonly = true;\n        const type = this.tsTryParseTypeAnnotation();\n        if (type) property.typeAnnotation = type;\n        this.tsParseTypeMemberSemicolon();\n        return this.finishNode(property, \"TSPropertySignature\");\n      }\n    }\n\n    tsParseTypeMember(): N.TsTypeElement {\n      const node: any = this.startNode();\n\n      if (this.match(tt.parenL) || this.match(tt.lt)) {\n        return this.tsParseSignatureMember(\"TSCallSignatureDeclaration\", node);\n      }\n\n      if (this.match(tt._new)) {\n        const id = this.startNode<N.Identifier>();\n        this.next();\n        if (this.match(tt.parenL) || this.match(tt.lt)) {\n          return this.tsParseSignatureMember(\n            \"TSConstructSignatureDeclaration\",\n            node,\n          );\n        } else {\n          node.key = this.createIdentifier(id, \"new\");\n          return this.tsParsePropertyOrMethodSignature(node, false);\n        }\n      }\n\n      this.tsParseModifiers(\n        {\n          allowedModifiers: [\"readonly\"],\n          disallowedModifiers: [\n            \"declare\",\n            \"abstract\",\n            \"private\",\n            \"protected\",\n            \"public\",\n            \"static\",\n            \"override\",\n          ],\n        },\n        node,\n      );\n\n      const idx = this.tsTryParseIndexSignature(node);\n      if (idx) {\n        return idx;\n      }\n\n      super.parsePropertyName(node);\n      if (\n        !node.computed &&\n        node.key.type === \"Identifier\" &&\n        (node.key.name === \"get\" || node.key.name === \"set\") &&\n        this.tsTokenCanFollowModifier()\n      ) {\n        node.kind = node.key.name;\n        super.parsePropertyName(node);\n      }\n      return this.tsParsePropertyOrMethodSignature(node, !!node.readonly);\n    }\n\n    tsParseTypeLiteral(): N.TsTypeLiteral {\n      const node = this.startNode<N.TsTypeLiteral>();\n      node.members = this.tsParseObjectTypeMembers();\n      return this.finishNode(node, \"TSTypeLiteral\");\n    }\n\n    tsParseObjectTypeMembers(): Array<N.TsTypeElement> {\n      this.expect(tt.braceL);\n      const members = this.tsParseList(\n        \"TypeMembers\",\n        this.tsParseTypeMember.bind(this),\n      );\n      this.expect(tt.braceR);\n      return members;\n    }\n\n    tsIsStartOfMappedType(): boolean {\n      this.next();\n      if (this.eat(tt.plusMin)) {\n        return this.isContextual(tt._readonly);\n      }\n      if (this.isContextual(tt._readonly)) {\n        this.next();\n      }\n      if (!this.match(tt.bracketL)) {\n        return false;\n      }\n      this.next();\n      if (!this.tsIsIdentifier()) {\n        return false;\n      }\n      this.next();\n      return this.match(tt._in);\n    }\n\n    tsParseMappedTypeParameter(): N.TsTypeParameter {\n      const node = this.startNode<N.TsTypeParameter>();\n      node.name = this.tsParseTypeParameterName();\n      node.constraint = this.tsExpectThenParseType(tt._in);\n      return this.finishNode(node, \"TSTypeParameter\");\n    }\n\n    tsParseMappedType(): N.TsMappedType {\n      const node = this.startNode<N.TsMappedType>();\n\n      this.expect(tt.braceL);\n\n      if (this.match(tt.plusMin)) {\n        node.readonly = this.state.value;\n        this.next();\n        this.expectContextual(tt._readonly);\n      } else if (this.eatContextual(tt._readonly)) {\n        node.readonly = true;\n      }\n\n      this.expect(tt.bracketL);\n      node.typeParameter = this.tsParseMappedTypeParameter();\n      node.nameType = this.eatContextual(tt._as) ? this.tsParseType() : null;\n\n      this.expect(tt.bracketR);\n\n      if (this.match(tt.plusMin)) {\n        node.optional = this.state.value;\n        this.next();\n        this.expect(tt.question);\n      } else if (this.eat(tt.question)) {\n        node.optional = true;\n      }\n\n      node.typeAnnotation = this.tsTryParseType();\n      this.semicolon();\n      this.expect(tt.braceR);\n\n      return this.finishNode(node, \"TSMappedType\");\n    }\n\n    tsParseTupleType(): N.TsTupleType {\n      const node = this.startNode<N.TsTupleType>();\n      node.elementTypes = this.tsParseBracketedList(\n        \"TupleElementTypes\",\n        this.tsParseTupleElementType.bind(this),\n        /* bracket */ true,\n        /* skipFirstToken */ false,\n      );\n\n      // Validate the elementTypes to ensure that no mandatory elements\n      // follow optional elements\n      let seenOptionalElement = false;\n      let labeledElements: boolean | null = null;\n      node.elementTypes.forEach(elementNode => {\n        const { type } = elementNode;\n\n        if (\n          seenOptionalElement &&\n          type !== \"TSRestType\" &&\n          type !== \"TSOptionalType\" &&\n          !(type === \"TSNamedTupleMember\" && elementNode.optional)\n        ) {\n          this.raise(TSErrors.OptionalTypeBeforeRequired, {\n            at: elementNode,\n          });\n        }\n\n        seenOptionalElement ||=\n          (type === \"TSNamedTupleMember\" && elementNode.optional) ||\n          type === \"TSOptionalType\";\n\n        // When checking labels, check the argument of the spread operator\n        let checkType = type;\n        if (type === \"TSRestType\") {\n          elementNode = elementNode.typeAnnotation;\n          checkType = elementNode.type;\n        }\n\n        const isLabeled = checkType === \"TSNamedTupleMember\";\n        labeledElements ??= isLabeled;\n        if (labeledElements !== isLabeled) {\n          this.raise(TSErrors.MixedLabeledAndUnlabeledElements, {\n            at: elementNode,\n          });\n        }\n      });\n\n      return this.finishNode(node, \"TSTupleType\");\n    }\n\n    tsParseTupleElementType(): N.TsNamedTupleMember | N.TsType {\n      // parses `...TsType[]`\n\n      const { startLoc } = this.state;\n\n      const rest = this.eat(tt.ellipsis);\n\n      let labeled: boolean;\n      let label: N.Identifier;\n      let optional: boolean;\n      let type: N.TsNamedTupleMember | N.TsType;\n\n      const isWord = tokenIsKeywordOrIdentifier(this.state.type);\n      const chAfterWord = isWord ? this.lookaheadCharCode() : null;\n      if (chAfterWord === charCodes.colon) {\n        labeled = true;\n        optional = false;\n        label = this.parseIdentifier(true);\n        this.expect(tt.colon);\n        type = this.tsParseType();\n      } else if (chAfterWord === charCodes.questionMark) {\n        optional = true;\n        const startLoc = this.state.startLoc;\n        const wordName = this.state.value;\n        const typeOrLabel = this.tsParseNonArrayType();\n\n        if (this.lookaheadCharCode() === charCodes.colon) {\n          labeled = true;\n          label = this.createIdentifier(\n            this.startNodeAt<N.Identifier>(startLoc),\n            wordName,\n          );\n          this.expect(tt.question);\n          this.expect(tt.colon);\n          type = this.tsParseType();\n        } else {\n          labeled = false;\n          type = typeOrLabel;\n          this.expect(tt.question);\n        }\n      } else {\n        type = this.tsParseType();\n        optional = this.eat(tt.question);\n        // In this case (labeled === true) could be only in invalid label.\n        // E.g. [x.y:type]\n        // An error is raised while processing node.\n        labeled = this.eat(tt.colon);\n      }\n\n      if (labeled) {\n        let labeledNode: Undone<N.TsNamedTupleMember>;\n        if (label) {\n          labeledNode = this.startNodeAtNode<N.TsNamedTupleMember>(label);\n          labeledNode.optional = optional;\n          labeledNode.label = label;\n          labeledNode.elementType = type;\n\n          if (this.eat(tt.question)) {\n            labeledNode.optional = true;\n            this.raise(TSErrors.TupleOptionalAfterType, {\n              at: this.state.lastTokStartLoc,\n            });\n          }\n        } else {\n          labeledNode = this.startNodeAtNode<N.TsNamedTupleMember>(type);\n          labeledNode.optional = optional;\n          this.raise(TSErrors.InvalidTupleMemberLabel, { at: type });\n          // @ts-expect-error This produces an invalid AST, but at least we don't drop\n          // nodes representing the invalid source.\n          labeledNode.label = type;\n          labeledNode.elementType = this.tsParseType();\n        }\n        type = this.finishNode(labeledNode, \"TSNamedTupleMember\");\n      } else if (optional) {\n        const optionalTypeNode = this.startNodeAtNode<N.TsOptionalType>(type);\n        optionalTypeNode.typeAnnotation = type;\n        type = this.finishNode(optionalTypeNode, \"TSOptionalType\");\n      }\n\n      if (rest) {\n        const restNode = this.startNodeAt<N.TsRestType>(startLoc);\n        restNode.typeAnnotation = type;\n        type = this.finishNode(restNode, \"TSRestType\");\n      }\n\n      return type;\n    }\n\n    tsParseParenthesizedType(): N.TsParenthesizedType {\n      const node = this.startNode<N.TsParenthesizedType>();\n      this.expect(tt.parenL);\n      node.typeAnnotation = this.tsParseType();\n      this.expect(tt.parenR);\n      return this.finishNode(node, \"TSParenthesizedType\");\n    }\n\n    tsParseFunctionOrConstructorType(\n      type: \"TSFunctionType\" | \"TSConstructorType\",\n      abstract?: boolean,\n    ): N.TsFunctionOrConstructorType {\n      const node = this.startNode<\n        N.TsFunctionOrConstructorType | N.TsConstructorType\n      >();\n      if (type === \"TSConstructorType\") {\n        (node as Undone<N.TsConstructorType>).abstract = !!abstract;\n        if (abstract) this.next();\n        this.next(); // eat `new`\n      }\n      this.tsInAllowConditionalTypesContext(() =>\n        this.tsFillSignature(tt.arrow, node),\n      );\n      return this.finishNode(node, type);\n    }\n\n    tsParseLiteralTypeNode(): N.TsLiteralType {\n      const node = this.startNode<N.TsLiteralType>();\n      switch (this.state.type) {\n        case tt.num:\n        case tt.bigint:\n        case tt.string:\n        case tt._true:\n        case tt._false:\n          // For compatibility to estree we cannot call parseLiteral directly here\n          // @ts-expect-error refine typings\n          node.literal = super.parseExprAtom();\n          break;\n        default:\n          this.unexpected();\n      }\n      return this.finishNode(node, \"TSLiteralType\");\n    }\n\n    tsParseTemplateLiteralType(): N.TsType {\n      const node = this.startNode<N.TsLiteralType>();\n      node.literal = super.parseTemplate(false);\n      return this.finishNode(node, \"TSLiteralType\");\n    }\n\n    parseTemplateSubstitution(): N.TsType | N.Node {\n      if (this.state.inType) return this.tsParseType();\n      return super.parseTemplateSubstitution();\n    }\n\n    tsParseThisTypeOrThisTypePredicate(): N.TsThisType | N.TsTypePredicate {\n      const thisKeyword = this.tsParseThisTypeNode();\n      if (this.isContextual(tt._is) && !this.hasPrecedingLineBreak()) {\n        return this.tsParseThisTypePredicate(thisKeyword);\n      } else {\n        return thisKeyword;\n      }\n    }\n\n    tsParseNonArrayType(): N.TsType {\n      switch (this.state.type) {\n        case tt.string:\n        case tt.num:\n        case tt.bigint:\n        case tt._true:\n        case tt._false:\n          return this.tsParseLiteralTypeNode();\n        case tt.plusMin:\n          if (this.state.value === \"-\") {\n            const node = this.startNode<N.TsLiteralType>();\n            const nextToken = this.lookahead();\n            if (nextToken.type !== tt.num && nextToken.type !== tt.bigint) {\n              this.unexpected();\n            }\n            // @ts-expect-error: parseMaybeUnary must returns unary expression\n            node.literal = this.parseMaybeUnary();\n            return this.finishNode(node, \"TSLiteralType\");\n          }\n          break;\n        case tt._this:\n          return this.tsParseThisTypeOrThisTypePredicate();\n        case tt._typeof:\n          return this.tsParseTypeQuery();\n        case tt._import:\n          return this.tsParseImportType();\n        case tt.braceL:\n          return this.tsLookAhead(this.tsIsStartOfMappedType.bind(this))\n            ? this.tsParseMappedType()\n            : this.tsParseTypeLiteral();\n        case tt.bracketL:\n          return this.tsParseTupleType();\n        case tt.parenL:\n          if (process.env.BABEL_8_BREAKING) {\n            if (!this.options.createParenthesizedExpressions) {\n              const startLoc = this.state.startLoc;\n              this.next();\n              const type = this.tsParseType();\n              this.expect(tt.parenR);\n              this.addExtra(type, \"parenthesized\", true);\n              this.addExtra(type, \"parenStart\", startLoc.index);\n              return type;\n            }\n          }\n\n          return this.tsParseParenthesizedType();\n        case tt.templateNonTail:\n        case tt.templateTail:\n          return this.tsParseTemplateLiteralType();\n        default: {\n          const { type } = this.state;\n          if (\n            tokenIsIdentifier(type) ||\n            type === tt._void ||\n            type === tt._null\n          ) {\n            const nodeType =\n              type === tt._void\n                ? \"TSVoidKeyword\"\n                : type === tt._null\n                ? \"TSNullKeyword\"\n                : keywordTypeFromName(this.state.value);\n            if (\n              nodeType !== undefined &&\n              this.lookaheadCharCode() !== charCodes.dot\n            ) {\n              const node = this.startNode<N.TsKeywordType>();\n              this.next();\n              return this.finishNode(node, nodeType);\n            }\n            return this.tsParseTypeReference();\n          }\n        }\n      }\n\n      this.unexpected();\n    }\n\n    tsParseArrayTypeOrHigher(): N.TsType {\n      let type = this.tsParseNonArrayType();\n      while (!this.hasPrecedingLineBreak() && this.eat(tt.bracketL)) {\n        if (this.match(tt.bracketR)) {\n          const node = this.startNodeAtNode<N.TsArrayType>(type);\n          node.elementType = type;\n          this.expect(tt.bracketR);\n          type = this.finishNode(node, \"TSArrayType\");\n        } else {\n          const node = this.startNodeAtNode<N.TsIndexedAccessType>(type);\n          node.objectType = type;\n          node.indexType = this.tsParseType();\n          this.expect(tt.bracketR);\n          type = this.finishNode(node, \"TSIndexedAccessType\");\n        }\n      }\n      return type;\n    }\n\n    tsParseTypeOperator(): N.TsTypeOperator {\n      const node = this.startNode<N.TsTypeOperator>();\n      const operator = this.state.value;\n      this.next(); // eat operator\n      node.operator = operator;\n      node.typeAnnotation = this.tsParseTypeOperatorOrHigher();\n\n      if (operator === \"readonly\") {\n        this.tsCheckTypeAnnotationForReadOnly(\n          // @ts-expect-error todo(flow->ts)\n          node,\n        );\n      }\n\n      return this.finishNode(node, \"TSTypeOperator\");\n    }\n\n    tsCheckTypeAnnotationForReadOnly(node: N.Node) {\n      switch (node.typeAnnotation.type) {\n        case \"TSTupleType\":\n        case \"TSArrayType\":\n          return;\n        default:\n          this.raise(TSErrors.UnexpectedReadonly, { at: node });\n      }\n    }\n\n    tsParseInferType(): N.TsInferType {\n      const node = this.startNode<N.TsInferType>();\n      this.expectContextual(tt._infer);\n      const typeParameter = this.startNode<N.TsTypeParameter>();\n      typeParameter.name = this.tsParseTypeParameterName();\n      typeParameter.constraint = this.tsTryParse(() =>\n        this.tsParseConstraintForInferType(),\n      );\n      node.typeParameter = this.finishNode(typeParameter, \"TSTypeParameter\");\n      return this.finishNode(node, \"TSInferType\");\n    }\n\n    tsParseConstraintForInferType() {\n      if (this.eat(tt._extends)) {\n        const constraint = this.tsInDisallowConditionalTypesContext(() =>\n          this.tsParseType(),\n        );\n        if (\n          this.state.inDisallowConditionalTypesContext ||\n          !this.match(tt.question)\n        ) {\n          return constraint;\n        }\n      }\n    }\n\n    tsParseTypeOperatorOrHigher(): N.TsType {\n      const isTypeOperator =\n        tokenIsTSTypeOperator(this.state.type) && !this.state.containsEsc;\n      return isTypeOperator\n        ? this.tsParseTypeOperator()\n        : this.isContextual(tt._infer)\n        ? this.tsParseInferType()\n        : this.tsInAllowConditionalTypesContext(() =>\n            this.tsParseArrayTypeOrHigher(),\n          );\n    }\n\n    tsParseUnionOrIntersectionType(\n      kind: \"TSUnionType\" | \"TSIntersectionType\",\n      parseConstituentType: () => N.TsType,\n      operator: TokenType,\n    ): N.TsType {\n      const node = this.startNode<N.TsUnionType | N.TsIntersectionType>();\n      const hasLeadingOperator = this.eat(operator);\n      const types = [];\n      do {\n        types.push(parseConstituentType());\n      } while (this.eat(operator));\n      if (types.length === 1 && !hasLeadingOperator) {\n        return types[0];\n      }\n      node.types = types;\n      return this.finishNode(node, kind);\n    }\n\n    tsParseIntersectionTypeOrHigher(): N.TsType {\n      return this.tsParseUnionOrIntersectionType(\n        \"TSIntersectionType\",\n        this.tsParseTypeOperatorOrHigher.bind(this),\n        tt.bitwiseAND,\n      );\n    }\n\n    tsParseUnionTypeOrHigher() {\n      return this.tsParseUnionOrIntersectionType(\n        \"TSUnionType\",\n        this.tsParseIntersectionTypeOrHigher.bind(this),\n        tt.bitwiseOR,\n      );\n    }\n\n    tsIsStartOfFunctionType() {\n      if (this.match(tt.lt)) {\n        return true;\n      }\n      return (\n        this.match(tt.parenL) &&\n        this.tsLookAhead(this.tsIsUnambiguouslyStartOfFunctionType.bind(this))\n      );\n    }\n\n    tsSkipParameterStart(): boolean {\n      if (tokenIsIdentifier(this.state.type) || this.match(tt._this)) {\n        this.next();\n        return true;\n      }\n\n      if (this.match(tt.braceL)) {\n        // Return true if we can parse an object pattern without errors\n        const { errors } = this.state;\n        const previousErrorCount = errors.length;\n        try {\n          this.parseObjectLike(tt.braceR, true);\n          return errors.length === previousErrorCount;\n        } catch {\n          return false;\n        }\n      }\n\n      if (this.match(tt.bracketL)) {\n        this.next();\n        // Return true if we can parse an array pattern without errors\n        const { errors } = this.state;\n        const previousErrorCount = errors.length;\n        try {\n          super.parseBindingList(\n            tt.bracketR,\n            charCodes.rightSquareBracket,\n            ParseBindingListFlags.ALLOW_EMPTY,\n          );\n          return errors.length === previousErrorCount;\n        } catch {\n          return false;\n        }\n      }\n\n      return false;\n    }\n\n    tsIsUnambiguouslyStartOfFunctionType(): boolean {\n      this.next();\n      if (this.match(tt.parenR) || this.match(tt.ellipsis)) {\n        // ( )\n        // ( ...\n        return true;\n      }\n      if (this.tsSkipParameterStart()) {\n        if (\n          this.match(tt.colon) ||\n          this.match(tt.comma) ||\n          this.match(tt.question) ||\n          this.match(tt.eq)\n        ) {\n          // ( xxx :\n          // ( xxx ,\n          // ( xxx ?\n          // ( xxx =\n          return true;\n        }\n        if (this.match(tt.parenR)) {\n          this.next();\n          if (this.match(tt.arrow)) {\n            // ( xxx ) =>\n            return true;\n          }\n        }\n      }\n      return false;\n    }\n\n    tsParseTypeOrTypePredicateAnnotation(\n      returnToken: TokenType,\n    ): N.TsTypeAnnotation {\n      return this.tsInType(() => {\n        const t = this.startNode<N.TsTypeAnnotation>();\n        this.expect(returnToken);\n\n        const node = this.startNode<N.TsTypePredicate>();\n\n        const asserts = !!this.tsTryParse(\n          this.tsParseTypePredicateAsserts.bind(this),\n        );\n\n        if (asserts && this.match(tt._this)) {\n          // When asserts is false, thisKeyword is handled by tsParseNonArrayType\n          // : asserts this is type\n          let thisTypePredicate = this.tsParseThisTypeOrThisTypePredicate();\n          // if it turns out to be a `TSThisType`, wrap it with `TSTypePredicate`\n          // : asserts this\n          if (thisTypePredicate.type === \"TSThisType\") {\n            node.parameterName = thisTypePredicate;\n            node.asserts = true;\n            (node as N.TsTypePredicate).typeAnnotation = null;\n            thisTypePredicate = this.finishNode(node, \"TSTypePredicate\");\n          } else {\n            this.resetStartLocationFromNode(thisTypePredicate, node);\n            thisTypePredicate.asserts = true;\n          }\n          t.typeAnnotation = thisTypePredicate;\n          return this.finishNode(t, \"TSTypeAnnotation\");\n        }\n\n        const typePredicateVariable =\n          this.tsIsIdentifier() &&\n          this.tsTryParse(this.tsParseTypePredicatePrefix.bind(this));\n\n        if (!typePredicateVariable) {\n          if (!asserts) {\n            // : type\n            return this.tsParseTypeAnnotation(/* eatColon */ false, t);\n          }\n\n          // : asserts foo\n          node.parameterName = this.parseIdentifier();\n          node.asserts = asserts;\n          (node as N.TsTypePredicate).typeAnnotation = null;\n          t.typeAnnotation = this.finishNode(node, \"TSTypePredicate\");\n          return this.finishNode(t, \"TSTypeAnnotation\");\n        }\n\n        // : asserts foo is type\n        const type = this.tsParseTypeAnnotation(/* eatColon */ false);\n        node.parameterName = typePredicateVariable;\n        node.typeAnnotation = type;\n        node.asserts = asserts;\n        t.typeAnnotation = this.finishNode(node, \"TSTypePredicate\");\n        return this.finishNode(t, \"TSTypeAnnotation\");\n      });\n    }\n\n    tsTryParseTypeOrTypePredicateAnnotation(): N.TsTypeAnnotation | undefined {\n      if (this.match(tt.colon)) {\n        return this.tsParseTypeOrTypePredicateAnnotation(tt.colon);\n      }\n    }\n\n    tsTryParseTypeAnnotation(): N.TsTypeAnnotation | undefined {\n      if (this.match(tt.colon)) {\n        return this.tsParseTypeAnnotation();\n      }\n    }\n\n    tsTryParseType(): N.TsType | undefined {\n      return this.tsEatThenParseType(tt.colon);\n    }\n\n    tsParseTypePredicatePrefix(): N.Identifier | undefined {\n      const id = this.parseIdentifier();\n      if (this.isContextual(tt._is) && !this.hasPrecedingLineBreak()) {\n        this.next();\n        return id;\n      }\n    }\n\n    tsParseTypePredicateAsserts(): boolean {\n      if (this.state.type !== tt._asserts) {\n        return false;\n      }\n      const containsEsc = this.state.containsEsc;\n      this.next();\n      if (!tokenIsIdentifier(this.state.type) && !this.match(tt._this)) {\n        return false;\n      }\n\n      if (containsEsc) {\n        this.raise(Errors.InvalidEscapedReservedWord, {\n          at: this.state.lastTokStartLoc,\n          reservedWord: \"asserts\",\n        });\n      }\n\n      return true;\n    }\n\n    tsParseTypeAnnotation(\n      eatColon = true,\n      t: Undone<N.TsTypeAnnotation> = this.startNode<N.TsTypeAnnotation>(),\n    ): N.TsTypeAnnotation {\n      this.tsInType(() => {\n        if (eatColon) this.expect(tt.colon);\n        t.typeAnnotation = this.tsParseType();\n      });\n      return this.finishNode(t, \"TSTypeAnnotation\");\n    }\n\n    /** Be sure to be in a type context before calling this, using `tsInType`. */\n    tsParseType(): N.TsType {\n      // Need to set `state.inType` so that we don't parse JSX in a type context.\n      assert(this.state.inType);\n      const type = this.tsParseNonConditionalType();\n\n      if (\n        this.state.inDisallowConditionalTypesContext ||\n        this.hasPrecedingLineBreak() ||\n        !this.eat(tt._extends)\n      ) {\n        return type;\n      }\n      const node = this.startNodeAtNode<N.TsConditionalType>(type);\n      node.checkType = type;\n\n      node.extendsType = this.tsInDisallowConditionalTypesContext(() =>\n        this.tsParseNonConditionalType(),\n      );\n\n      this.expect(tt.question);\n      node.trueType = this.tsInAllowConditionalTypesContext(() =>\n        this.tsParseType(),\n      );\n\n      this.expect(tt.colon);\n      node.falseType = this.tsInAllowConditionalTypesContext(() =>\n        this.tsParseType(),\n      );\n\n      return this.finishNode(node, \"TSConditionalType\");\n    }\n\n    isAbstractConstructorSignature(): boolean {\n      return (\n        this.isContextual(tt._abstract) && this.lookahead().type === tt._new\n      );\n    }\n\n    tsParseNonConditionalType(): N.TsType {\n      if (this.tsIsStartOfFunctionType()) {\n        return this.tsParseFunctionOrConstructorType(\"TSFunctionType\");\n      }\n      if (this.match(tt._new)) {\n        // As in `new () => Date`\n        return this.tsParseFunctionOrConstructorType(\"TSConstructorType\");\n      } else if (this.isAbstractConstructorSignature()) {\n        // As in `abstract new () => Date`\n        return this.tsParseFunctionOrConstructorType(\n          \"TSConstructorType\",\n          /* abstract */ true,\n        );\n      }\n      return this.tsParseUnionTypeOrHigher();\n    }\n\n    tsParseTypeAssertion(): N.TsTypeAssertion {\n      if (this.getPluginOption(\"typescript\", \"disallowAmbiguousJSXLike\")) {\n        this.raise(TSErrors.ReservedTypeAssertion, { at: this.state.startLoc });\n      }\n\n      const node = this.startNode<N.TsTypeAssertion>();\n      node.typeAnnotation = this.tsInType(() => {\n        this.next(); // \"<\"\n        return this.match(tt._const)\n          ? this.tsParseTypeReference()\n          : this.tsParseType();\n      });\n      this.expect(tt.gt);\n      node.expression = this.parseMaybeUnary();\n      return this.finishNode(node, \"TSTypeAssertion\");\n    }\n\n    tsParseHeritageClause(\n      token: \"extends\" | \"implements\",\n    ): Array<N.TsExpressionWithTypeArguments> {\n      const originalStartLoc = this.state.startLoc;\n\n      const delimitedList = this.tsParseDelimitedList(\n        \"HeritageClauseElement\",\n        () => {\n          const node = this.startNode<N.TsExpressionWithTypeArguments>();\n          node.expression = this.tsParseEntityName();\n          if (this.match(tt.lt)) {\n            node.typeParameters = this.tsParseTypeArguments();\n          }\n\n          return this.finishNode(node, \"TSExpressionWithTypeArguments\");\n        },\n      );\n\n      if (!delimitedList.length) {\n        this.raise(TSErrors.EmptyHeritageClauseType, {\n          at: originalStartLoc,\n          token,\n        });\n      }\n\n      return delimitedList;\n    }\n\n    tsParseInterfaceDeclaration(\n      node: Undone<N.TsInterfaceDeclaration>,\n      properties: {\n        declare?: true;\n      } = {},\n    ): N.TsInterfaceDeclaration | null {\n      if (this.hasFollowingLineBreak()) return null;\n      this.expectContextual(tt._interface);\n      if (properties.declare) node.declare = true;\n      if (tokenIsIdentifier(this.state.type)) {\n        node.id = this.parseIdentifier();\n        this.checkIdentifier(node.id, BIND_TS_INTERFACE);\n      } else {\n        node.id = null;\n        this.raise(TSErrors.MissingInterfaceName, { at: this.state.startLoc });\n      }\n\n      node.typeParameters = this.tsTryParseTypeParameters(\n        this.tsParseInOutConstModifiers,\n      );\n      if (this.eat(tt._extends)) {\n        node.extends = this.tsParseHeritageClause(\"extends\");\n      }\n      const body = this.startNode<N.TSInterfaceBody>();\n      body.body = this.tsInType(this.tsParseObjectTypeMembers.bind(this));\n      node.body = this.finishNode(body, \"TSInterfaceBody\");\n      return this.finishNode(node, \"TSInterfaceDeclaration\");\n    }\n\n    tsParseTypeAliasDeclaration(\n      node: N.TsTypeAliasDeclaration,\n    ): N.TsTypeAliasDeclaration {\n      node.id = this.parseIdentifier();\n      this.checkIdentifier(node.id, BIND_TS_TYPE);\n\n      node.typeAnnotation = this.tsInType(() => {\n        node.typeParameters = this.tsTryParseTypeParameters(\n          this.tsParseInOutModifiers,\n        );\n\n        this.expect(tt.eq);\n\n        if (\n          this.isContextual(tt._intrinsic) &&\n          this.lookahead().type !== tt.dot\n        ) {\n          const node = this.startNode<N.TsKeywordType>();\n          this.next();\n          return this.finishNode(node, \"TSIntrinsicKeyword\");\n        }\n\n        return this.tsParseType();\n      });\n\n      this.semicolon();\n      return this.finishNode(node, \"TSTypeAliasDeclaration\");\n    }\n\n    tsInNoContext<T>(cb: () => T): T {\n      const oldContext = this.state.context;\n      this.state.context = [oldContext[0]];\n      try {\n        return cb();\n      } finally {\n        this.state.context = oldContext;\n      }\n    }\n\n    /**\n     * Runs `cb` in a type context.\n     * This should be called one token *before* the first type token,\n     * so that the call to `next()` is run in type context.\n     */\n    tsInType<T>(cb: () => T): T {\n      const oldInType = this.state.inType;\n      this.state.inType = true;\n      try {\n        return cb();\n      } finally {\n        this.state.inType = oldInType;\n      }\n    }\n\n    tsInDisallowConditionalTypesContext<T>(cb: () => T): T {\n      const oldInDisallowConditionalTypesContext =\n        this.state.inDisallowConditionalTypesContext;\n      this.state.inDisallowConditionalTypesContext = true;\n      try {\n        return cb();\n      } finally {\n        this.state.inDisallowConditionalTypesContext =\n          oldInDisallowConditionalTypesContext;\n      }\n    }\n\n    tsInAllowConditionalTypesContext<T>(cb: () => T): T {\n      const oldInDisallowConditionalTypesContext =\n        this.state.inDisallowConditionalTypesContext;\n      this.state.inDisallowConditionalTypesContext = false;\n      try {\n        return cb();\n      } finally {\n        this.state.inDisallowConditionalTypesContext =\n          oldInDisallowConditionalTypesContext;\n      }\n    }\n\n    tsEatThenParseType(token: TokenType): N.TsType | undefined {\n      if (this.match(token)) {\n        return this.tsNextThenParseType();\n      }\n    }\n\n    tsExpectThenParseType(token: TokenType): N.TsType {\n      return this.tsInType(() => {\n        this.expect(token);\n        return this.tsParseType();\n      });\n    }\n\n    tsNextThenParseType(): N.TsType {\n      return this.tsInType(() => {\n        this.next();\n        return this.tsParseType();\n      });\n    }\n\n    tsParseEnumMember(): N.TsEnumMember {\n      const node = this.startNode<N.TsEnumMember>();\n      // Computed property names are grammar errors in an enum, so accept just string literal or identifier.\n      node.id = this.match(tt.string)\n        ? super.parseStringLiteral(this.state.value)\n        : this.parseIdentifier(/* liberal */ true);\n      if (this.eat(tt.eq)) {\n        node.initializer = super.parseMaybeAssignAllowIn();\n      }\n      return this.finishNode(node, \"TSEnumMember\");\n    }\n\n    tsParseEnumDeclaration(\n      node: Undone<N.TsEnumDeclaration>,\n      properties: {\n        const?: true;\n        declare?: true;\n      } = {},\n    ): N.TsEnumDeclaration {\n      if (properties.const) node.const = true;\n      if (properties.declare) node.declare = true;\n      this.expectContextual(tt._enum);\n      node.id = this.parseIdentifier();\n      this.checkIdentifier(\n        node.id,\n        node.const ? BIND_TS_CONST_ENUM : BIND_TS_ENUM,\n      );\n\n      this.expect(tt.braceL);\n      node.members = this.tsParseDelimitedList(\n        \"EnumMembers\",\n        this.tsParseEnumMember.bind(this),\n      );\n      this.expect(tt.braceR);\n      return this.finishNode(node, \"TSEnumDeclaration\");\n    }\n\n    tsParseModuleBlock(): N.TsModuleBlock {\n      const node = this.startNode<N.TsModuleBlock>();\n      this.scope.enter(SCOPE_OTHER);\n\n      this.expect(tt.braceL);\n      // Inside of a module block is considered \"top-level\", meaning it can have imports and exports.\n      super.parseBlockOrModuleBlockBody(\n        (node.body = []),\n        /* directives */ undefined,\n        /* topLevel */ true,\n        /* end */ tt.braceR,\n      );\n      this.scope.exit();\n      return this.finishNode(node, \"TSModuleBlock\");\n    }\n\n    tsParseModuleOrNamespaceDeclaration(\n      node: Undone<N.TsModuleDeclaration>,\n      nested: boolean = false,\n    ): N.TsModuleDeclaration {\n      node.id = this.parseIdentifier();\n\n      if (!nested) {\n        this.checkIdentifier(node.id, BIND_TS_NAMESPACE);\n      }\n\n      if (this.eat(tt.dot)) {\n        const inner = this.startNode<N.TsModuleDeclaration>();\n        this.tsParseModuleOrNamespaceDeclaration(inner, true);\n        // @ts-expect-error Fixme: refine typings\n        node.body = inner;\n      } else {\n        this.scope.enter(SCOPE_TS_MODULE);\n        this.prodParam.enter(PARAM);\n        node.body = this.tsParseModuleBlock();\n        this.prodParam.exit();\n        this.scope.exit();\n      }\n      return this.finishNode(node, \"TSModuleDeclaration\");\n    }\n\n    tsParseAmbientExternalModuleDeclaration(\n      node: N.TsModuleDeclaration,\n    ): N.TsModuleDeclaration {\n      if (this.isContextual(tt._global)) {\n        node.global = true;\n        node.id = this.parseIdentifier();\n      } else if (this.match(tt.string)) {\n        node.id = super.parseStringLiteral(this.state.value);\n      } else {\n        this.unexpected();\n      }\n      if (this.match(tt.braceL)) {\n        this.scope.enter(SCOPE_TS_MODULE);\n        this.prodParam.enter(PARAM);\n        node.body = this.tsParseModuleBlock();\n        this.prodParam.exit();\n        this.scope.exit();\n      } else {\n        this.semicolon();\n      }\n\n      return this.finishNode(node, \"TSModuleDeclaration\");\n    }\n\n    tsParseImportEqualsDeclaration(\n      node: Undone<N.TsImportEqualsDeclaration>,\n      maybeDefaultIdentifier?: N.Identifier | null,\n      isExport?: boolean,\n    ): N.TsImportEqualsDeclaration {\n      node.isExport = isExport || false;\n      node.id = maybeDefaultIdentifier || this.parseIdentifier();\n      this.checkIdentifier(node.id, BIND_FLAGS_TS_IMPORT);\n      this.expect(tt.eq);\n      const moduleReference = this.tsParseModuleReference();\n      if (\n        node.importKind === \"type\" &&\n        moduleReference.type !== \"TSExternalModuleReference\"\n      ) {\n        this.raise(TSErrors.ImportAliasHasImportType, {\n          at: moduleReference,\n        });\n      }\n      node.moduleReference = moduleReference;\n      this.semicolon();\n      return this.finishNode(node, \"TSImportEqualsDeclaration\");\n    }\n\n    tsIsExternalModuleReference(): boolean {\n      return (\n        this.isContextual(tt._require) &&\n        this.lookaheadCharCode() === charCodes.leftParenthesis\n      );\n    }\n\n    tsParseModuleReference(): N.TsModuleReference {\n      return this.tsIsExternalModuleReference()\n        ? this.tsParseExternalModuleReference()\n        : this.tsParseEntityName(/* allowReservedWords */ false);\n    }\n\n    tsParseExternalModuleReference(): N.TsExternalModuleReference {\n      const node = this.startNode<N.TsExternalModuleReference>();\n      this.expectContextual(tt._require);\n      this.expect(tt.parenL);\n      if (!this.match(tt.string)) {\n        this.unexpected();\n      }\n      // For compatibility to estree we cannot call parseLiteral directly here\n      node.expression = super.parseExprAtom() as N.StringLiteral;\n      this.expect(tt.parenR);\n      this.sawUnambiguousESM = true;\n      return this.finishNode(node, \"TSExternalModuleReference\");\n    }\n\n    // Utilities\n\n    tsLookAhead<T>(f: () => T): T {\n      const state = this.state.clone();\n      const res = f();\n      this.state = state;\n      return res;\n    }\n\n    tsTryParseAndCatch<T extends N.NodeBase | undefined | null>(\n      f: () => T,\n    ): T | undefined | null {\n      const result = this.tryParse(\n        abort =>\n          // @ts-expect-error todo(flow->ts)\n          f() || abort(),\n      );\n\n      if (result.aborted || !result.node) return;\n      if (result.error) this.state = result.failState;\n      // @ts-expect-error refine typings\n      return result.node;\n    }\n\n    tsTryParse<T>(f: () => T | undefined | false): T | undefined {\n      const state = this.state.clone();\n      const result = f();\n      if (result !== undefined && result !== false) {\n        return result;\n      }\n      this.state = state;\n    }\n\n    tsTryParseDeclare(nany: any): N.Declaration | undefined {\n      if (this.isLineTerminator()) {\n        return;\n      }\n      let startType = this.state.type;\n      let kind: \"let\" | null;\n\n      if (this.isContextual(tt._let)) {\n        startType = tt._var;\n        kind = \"let\";\n      }\n\n      // @ts-expect-error refine typings\n      return this.tsInAmbientContext(() => {\n        switch (startType) {\n          case tt._function:\n            nany.declare = true;\n            return super.parseFunctionStatement(\n              nany,\n              /* async */ false,\n              /* isHangingDeclaration */ false,\n            );\n          case tt._class:\n            // While this is also set by tsParseExpressionStatement, we need to set it\n            // before parsing the class declaration to know how to register it in the scope.\n            nany.declare = true;\n            return this.parseClass(\n              nany,\n              /* isStatement */ true,\n              /* optionalId */ false,\n            );\n          case tt._enum:\n            return this.tsParseEnumDeclaration(nany, { declare: true });\n          case tt._global:\n            return this.tsParseAmbientExternalModuleDeclaration(nany);\n          case tt._const:\n          case tt._var:\n            if (!this.match(tt._const) || !this.isLookaheadContextual(\"enum\")) {\n              nany.declare = true;\n              return this.parseVarStatement(\n                nany,\n                kind || this.state.value,\n                true,\n              );\n            }\n\n            // `const enum = 0;` not allowed because \"enum\" is a strict mode reserved word.\n            this.expect(tt._const);\n            return this.tsParseEnumDeclaration(nany, {\n              const: true,\n              declare: true,\n            });\n          case tt._interface: {\n            const result = this.tsParseInterfaceDeclaration(nany, {\n              declare: true,\n            });\n            if (result) return result;\n          }\n          // fallthrough\n          default:\n            if (tokenIsIdentifier(startType)) {\n              return this.tsParseDeclaration(\n                nany,\n                this.state.value,\n                /* next */ true,\n                /* decorators */ null,\n              );\n            }\n        }\n      });\n    }\n\n    // Note: this won't be called unless the keyword is allowed in `shouldParseExportDeclaration`.\n    tsTryParseExportDeclaration(): N.Declaration | undefined {\n      return this.tsParseDeclaration(\n        this.startNode(),\n        this.state.value,\n        /* next */ true,\n        /* decorators */ null,\n      );\n    }\n\n    tsParseExpressionStatement(\n      node: Undone<N.TsModuleDeclaration>,\n      expr: N.Identifier,\n      decorators: N.Decorator[] | null,\n    ): N.Declaration | undefined {\n      switch (expr.name) {\n        case \"declare\": {\n          const declaration = this.tsTryParseDeclare(node);\n          if (declaration) {\n            declaration.declare = true;\n          }\n          return declaration;\n        }\n        case \"global\":\n          // `global { }` (with no `declare`) may appear inside an ambient module declaration.\n          // Would like to use tsParseAmbientExternalModuleDeclaration here, but already ran past \"global\".\n          if (this.match(tt.braceL)) {\n            this.scope.enter(SCOPE_TS_MODULE);\n            this.prodParam.enter(PARAM);\n            const mod = node;\n            mod.global = true;\n            mod.id = expr;\n            mod.body = this.tsParseModuleBlock();\n            this.scope.exit();\n            this.prodParam.exit();\n            return this.finishNode(mod, \"TSModuleDeclaration\");\n          }\n          break;\n\n        default:\n          return this.tsParseDeclaration(\n            node,\n            expr.name,\n            /* next */ false,\n            decorators,\n          );\n      }\n    }\n\n    // Common to tsTryParseDeclare, tsTryParseExportDeclaration, and tsParseExpressionStatement.\n    tsParseDeclaration(\n      node: any,\n      value: string,\n      next: boolean,\n      decorators: N.Decorator[] | null,\n    ): N.Declaration | undefined | null {\n      // no declaration apart from enum can be followed by a line break.\n      switch (value) {\n        case \"abstract\":\n          if (\n            this.tsCheckLineTerminator(next) &&\n            (this.match(tt._class) || tokenIsIdentifier(this.state.type))\n          ) {\n            return this.tsParseAbstractDeclaration(node, decorators);\n          }\n          break;\n\n        case \"module\":\n          if (this.tsCheckLineTerminator(next)) {\n            if (this.match(tt.string)) {\n              return this.tsParseAmbientExternalModuleDeclaration(node);\n            } else if (tokenIsIdentifier(this.state.type)) {\n              return this.tsParseModuleOrNamespaceDeclaration(node);\n            }\n          }\n          break;\n\n        case \"namespace\":\n          if (\n            this.tsCheckLineTerminator(next) &&\n            tokenIsIdentifier(this.state.type)\n          ) {\n            return this.tsParseModuleOrNamespaceDeclaration(node);\n          }\n          break;\n\n        case \"type\":\n          if (\n            this.tsCheckLineTerminator(next) &&\n            tokenIsIdentifier(this.state.type)\n          ) {\n            return this.tsParseTypeAliasDeclaration(node);\n          }\n          break;\n      }\n    }\n\n    tsCheckLineTerminator(next: boolean) {\n      if (next) {\n        if (this.hasFollowingLineBreak()) return false;\n        this.next();\n        return true;\n      }\n      return !this.isLineTerminator();\n    }\n\n    tsTryParseGenericAsyncArrowFunction(\n      startLoc: Position,\n    ): N.ArrowFunctionExpression | undefined {\n      if (!this.match(tt.lt)) return;\n\n      const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;\n      this.state.maybeInArrowParameters = true;\n\n      const res: Undone<N.ArrowFunctionExpression> | undefined =\n        this.tsTryParseAndCatch(() => {\n          const node = this.startNodeAt<N.ArrowFunctionExpression>(startLoc);\n          node.typeParameters = this.tsParseTypeParameters(\n            this.tsParseConstModifier,\n          );\n          // Don't use overloaded parseFunctionParams which would look for \"<\" again.\n          super.parseFunctionParams(node);\n          node.returnType = this.tsTryParseTypeOrTypePredicateAnnotation();\n          this.expect(tt.arrow);\n          return node;\n        });\n\n      this.state.maybeInArrowParameters = oldMaybeInArrowParameters;\n\n      if (!res) return;\n\n      return super.parseArrowExpression(\n        res,\n        /* params are already set */ null,\n        /* async */ true,\n      );\n    }\n\n    // Used when parsing type arguments from ES productions, where the first token\n    // has been created without state.inType. Thus we need to rescan the lt token.\n    tsParseTypeArgumentsInExpression(): N.TsTypeParameterInstantiation | void {\n      if (this.reScan_lt() !== tt.lt) return;\n      return this.tsParseTypeArguments();\n    }\n\n    tsParseTypeArguments(): N.TsTypeParameterInstantiation {\n      const node = this.startNode<N.TsTypeParameterInstantiation>();\n      node.params = this.tsInType(() =>\n        // Temporarily remove a JSX parsing context, which makes us scan different tokens.\n        this.tsInNoContext(() => {\n          this.expect(tt.lt);\n          return this.tsParseDelimitedList(\n            \"TypeParametersOrArguments\",\n            this.tsParseType.bind(this),\n          );\n        }),\n      );\n      if (node.params.length === 0) {\n        this.raise(TSErrors.EmptyTypeArguments, { at: node });\n      } else if (!this.state.inType && this.curContext() === tc.brace) {\n        // rescan `>` when we are no longer in type context and JSX parsing context\n        // since it was tokenized when `inType` is `true`.\n        this.reScan_lt_gt();\n      }\n      this.expect(tt.gt);\n      return this.finishNode(node, \"TSTypeParameterInstantiation\");\n    }\n\n    tsIsDeclarationStart(): boolean {\n      return tokenIsTSDeclarationStart(this.state.type);\n    }\n\n    // ======================================================\n    // OVERRIDES\n    // ======================================================\n\n    isExportDefaultSpecifier(): boolean {\n      if (this.tsIsDeclarationStart()) return false;\n      return super.isExportDefaultSpecifier();\n    }\n\n    parseAssignableListItem(\n      flags: ParseBindingListFlags,\n      decorators: N.Decorator[],\n    ): N.Pattern | N.TSParameterProperty {\n      // Store original location to include modifiers in range\n      const startLoc = this.state.startLoc;\n\n      const modified: ModifierBase = {};\n      this.tsParseModifiers(\n        {\n          allowedModifiers: [\n            \"public\",\n            \"private\",\n            \"protected\",\n            \"override\",\n            \"readonly\",\n          ],\n        },\n        modified,\n      );\n      const accessibility = modified.accessibility;\n      const override = modified.override;\n      const readonly = modified.readonly;\n      if (\n        !(flags & ParseBindingListFlags.IS_CONSTRUCTOR_PARAMS) &&\n        (accessibility || readonly || override)\n      ) {\n        this.raise(TSErrors.UnexpectedParameterModifier, { at: startLoc });\n      }\n\n      const left = this.parseMaybeDefault();\n      this.parseAssignableListItemTypes(left, flags);\n      const elt = this.parseMaybeDefault(left.loc.start, left);\n      if (accessibility || readonly || override) {\n        const pp = this.startNodeAt<N.TSParameterProperty>(startLoc);\n        if (decorators.length) {\n          pp.decorators = decorators;\n        }\n        if (accessibility) pp.accessibility = accessibility;\n        if (readonly) pp.readonly = readonly;\n        if (override) pp.override = override;\n        if (elt.type !== \"Identifier\" && elt.type !== \"AssignmentPattern\") {\n          this.raise(TSErrors.UnsupportedParameterPropertyKind, { at: pp });\n        }\n        pp.parameter = elt as any as N.Identifier | N.AssignmentPattern;\n        return this.finishNode(pp, \"TSParameterProperty\");\n      }\n\n      if (decorators.length) {\n        left.decorators = decorators;\n      }\n\n      return elt;\n    }\n\n    isSimpleParameter(node: N.Pattern | N.TSParameterProperty) {\n      return (\n        (node.type === \"TSParameterProperty\" &&\n          super.isSimpleParameter(node.parameter)) ||\n        super.isSimpleParameter(node)\n      );\n    }\n\n    tsDisallowOptionalPattern(node: Undone<N.Function>) {\n      for (const param of node.params) {\n        if (\n          param.type !== \"Identifier\" &&\n          (param as any).optional &&\n          !this.state.isAmbientContext\n        ) {\n          this.raise(TSErrors.PatternIsOptional, { at: param });\n        }\n      }\n    }\n\n    setArrowFunctionParameters(\n      node: Undone<N.ArrowFunctionExpression>,\n      params: N.Expression[],\n      trailingCommaLoc?: Position | null,\n    ): void {\n      super.setArrowFunctionParameters(node, params, trailingCommaLoc);\n      this.tsDisallowOptionalPattern(node);\n    }\n\n    parseFunctionBodyAndFinish<\n      T extends\n        | N.Function\n        | N.TSDeclareMethod\n        | N.TSDeclareFunction\n        | N.ClassPrivateMethod,\n    >(node: Undone<T>, type: T[\"type\"], isMethod: boolean = false): T {\n      if (this.match(tt.colon)) {\n        node.returnType = this.tsParseTypeOrTypePredicateAnnotation(tt.colon);\n      }\n\n      const bodilessType =\n        type === \"FunctionDeclaration\"\n          ? \"TSDeclareFunction\"\n          : type === \"ClassMethod\" || type === \"ClassPrivateMethod\"\n          ? \"TSDeclareMethod\"\n          : undefined;\n      if (bodilessType && !this.match(tt.braceL) && this.isLineTerminator()) {\n        return this.finishNode(node, bodilessType);\n      }\n      if (bodilessType === \"TSDeclareFunction\" && this.state.isAmbientContext) {\n        this.raise(TSErrors.DeclareFunctionHasImplementation, { at: node });\n        if ((node as Undone<N.FunctionDeclaration>).declare) {\n          return super.parseFunctionBodyAndFinish(node, bodilessType, isMethod);\n        }\n      }\n      this.tsDisallowOptionalPattern(node);\n\n      return super.parseFunctionBodyAndFinish(node, type, isMethod);\n    }\n\n    registerFunctionStatementId(node: N.Function): void {\n      if (!node.body && node.id) {\n        // Function ids are validated after parsing their body.\n        // For bodiless function, we need to do it here.\n        this.checkIdentifier(node.id, BIND_TS_AMBIENT);\n      } else {\n        super.registerFunctionStatementId(node);\n      }\n    }\n\n    tsCheckForInvalidTypeCasts(items: Array<N.Expression | undefined | null>) {\n      items.forEach(node => {\n        if (node?.type === \"TSTypeCastExpression\") {\n          this.raise(TSErrors.UnexpectedTypeAnnotation, {\n            at: node.typeAnnotation,\n          });\n        }\n      });\n    }\n\n    toReferencedList(\n      exprList: Array<N.Expression | undefined | null>,\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n      isInParens?: boolean,\n    ): Array<N.Expression | undefined | null> {\n      // Handles invalid scenarios like: `f(a:b)`, `(a:b);`, and `(a:b,c:d)`.\n      //\n      // Note that `f<T>(a:b)` goes through a different path and is handled\n      // in `parseSubscript` directly.\n      this.tsCheckForInvalidTypeCasts(exprList);\n      return exprList;\n    }\n\n    parseArrayLike(\n      close: TokenType,\n      canBePattern: boolean,\n      isTuple: boolean,\n      refExpressionErrors?: ExpressionErrors | null,\n    ): N.ArrayExpression | N.TupleExpression {\n      const node = super.parseArrayLike(\n        close,\n        canBePattern,\n        isTuple,\n        refExpressionErrors,\n      );\n\n      if (node.type === \"ArrayExpression\") {\n        this.tsCheckForInvalidTypeCasts(node.elements);\n      }\n\n      return node;\n    }\n\n    parseSubscript(\n      base: N.Expression,\n\n      startLoc: Position,\n      noCalls: boolean | undefined | null,\n      state: N.ParseSubscriptState,\n    ): N.Expression {\n      if (!this.hasPrecedingLineBreak() && this.match(tt.bang)) {\n        // When ! is consumed as a postfix operator (non-null assertion),\n        // disallow JSX tag forming after. e.g. When parsing `p! < n.p!`\n        // `<n.p` can not be a start of JSX tag\n        this.state.canStartJSXElement = false;\n        this.next();\n\n        const nonNullExpression =\n          this.startNodeAt<N.TsNonNullExpression>(startLoc);\n        nonNullExpression.expression = base;\n        return this.finishNode(nonNullExpression, \"TSNonNullExpression\");\n      }\n\n      let isOptionalCall = false;\n      if (\n        this.match(tt.questionDot) &&\n        this.lookaheadCharCode() === charCodes.lessThan\n      ) {\n        if (noCalls) {\n          state.stop = true;\n          return base;\n        }\n        state.optionalChainMember = isOptionalCall = true;\n        this.next();\n      }\n\n      // handles 'f<<T>'\n      if (this.match(tt.lt) || this.match(tt.bitShiftL)) {\n        let missingParenErrorLoc;\n        // tsTryParseAndCatch is expensive, so avoid if not necessary.\n        // There are number of things we are going to \"maybe\" parse, like type arguments on\n        // tagged template expressions. If any of them fail, walk it back and continue.\n        const result = this.tsTryParseAndCatch(() => {\n          if (!noCalls && this.atPossibleAsyncArrow(base)) {\n            // Almost certainly this is a generic async function `async <T>() => ...\n            // But it might be a call with a type argument `async<T>();`\n            const asyncArrowFn =\n              this.tsTryParseGenericAsyncArrowFunction(startLoc);\n            if (asyncArrowFn) {\n              return asyncArrowFn;\n            }\n          }\n\n          const typeArguments = this.tsParseTypeArgumentsInExpression();\n          if (!typeArguments) return;\n\n          if (isOptionalCall && !this.match(tt.parenL)) {\n            missingParenErrorLoc = this.state.curPosition();\n            return;\n          }\n\n          if (tokenIsTemplate(this.state.type)) {\n            const result = super.parseTaggedTemplateExpression(\n              base,\n\n              startLoc,\n              state,\n            );\n            result.typeParameters = typeArguments;\n            return result;\n          }\n\n          if (!noCalls && this.eat(tt.parenL)) {\n            const node = this.startNodeAt<\n              N.CallExpression | N.OptionalCallExpression\n            >(startLoc);\n            node.callee = base;\n            // possibleAsync always false here, because we would have handled it above.\n            // @ts-expect-error (won't be any undefined arguments)\n            node.arguments = this.parseCallExpressionArguments(\n              tt.parenR,\n              /* possibleAsync */ false,\n            );\n\n            // Handles invalid case: `f<T>(a:b)`\n            this.tsCheckForInvalidTypeCasts(node.arguments);\n\n            node.typeParameters = typeArguments;\n            if (state.optionalChainMember) {\n              (node as Undone<N.OptionalCallExpression>).optional =\n                isOptionalCall;\n            }\n\n            return this.finishCallExpression(node, state.optionalChainMember);\n          }\n\n          const tokenType = this.state.type;\n          if (\n            // a<b>>c is not (a<b>)>c, but a<(b>>c)\n            tokenType === tt.gt ||\n            // a<b>>>c is not (a<b>)>>c, but a<(b>>>c)\n            tokenType === tt.bitShiftR ||\n            // a<b>c is (a<b)>c\n            (tokenType !== tt.parenL &&\n              tokenCanStartExpression(tokenType) &&\n              !this.hasPrecedingLineBreak())\n          ) {\n            // Bail out.\n            return;\n          }\n\n          const node = this.startNodeAt<N.TsInstantiationExpression>(startLoc);\n          node.expression = base;\n          node.typeParameters = typeArguments;\n          return this.finishNode(node, \"TSInstantiationExpression\");\n        });\n\n        if (missingParenErrorLoc) {\n          this.unexpected(missingParenErrorLoc, tt.parenL);\n        }\n\n        if (result) {\n          if (\n            result.type === \"TSInstantiationExpression\" &&\n            (this.match(tt.dot) ||\n              (this.match(tt.questionDot) &&\n                this.lookaheadCharCode() !== charCodes.leftParenthesis))\n          ) {\n            this.raise(\n              TSErrors.InvalidPropertyAccessAfterInstantiationExpression,\n              { at: this.state.startLoc },\n            );\n          }\n          return result;\n        }\n      }\n\n      return super.parseSubscript(base, startLoc, noCalls, state);\n    }\n\n    parseNewCallee(node: N.NewExpression): void {\n      super.parseNewCallee(node);\n\n      const { callee } = node;\n      if (\n        callee.type === \"TSInstantiationExpression\" &&\n        !callee.extra?.parenthesized\n      ) {\n        node.typeParameters = callee.typeParameters;\n        node.callee = callee.expression;\n      }\n    }\n\n    parseExprOp(\n      left: N.Expression,\n      leftStartLoc: Position,\n      minPrec: number,\n    ): N.Expression {\n      let isSatisfies: boolean;\n      if (\n        tokenOperatorPrecedence(tt._in) > minPrec &&\n        !this.hasPrecedingLineBreak() &&\n        (this.isContextual(tt._as) ||\n          (isSatisfies = this.isContextual(tt._satisfies)))\n      ) {\n        const node = this.startNodeAt<\n          N.TsAsExpression | N.TsSatisfiesExpression\n        >(leftStartLoc);\n        node.expression = left;\n        node.typeAnnotation = this.tsInType(() => {\n          this.next(); // \"as\" or \"satisfies\"\n          if (this.match(tt._const)) {\n            if (isSatisfies) {\n              this.raise(Errors.UnexpectedKeyword, {\n                at: this.state.startLoc,\n                keyword: \"const\",\n              });\n            }\n            return this.tsParseTypeReference();\n          }\n\n          return this.tsParseType();\n        });\n        this.finishNode(\n          node,\n          isSatisfies ? \"TSSatisfiesExpression\" : \"TSAsExpression\",\n        );\n        // rescan `<`, `>` because they were scanned when this.state.inType was true\n        this.reScan_lt_gt();\n        return this.parseExprOp(\n          // @ts-expect-error todo(flow->ts)\n          node,\n          leftStartLoc,\n          minPrec,\n        );\n      }\n\n      return super.parseExprOp(left, leftStartLoc, minPrec);\n    }\n\n    checkReservedWord(\n      word: string,\n      startLoc: Position,\n      checkKeywords: boolean,\n      isBinding: boolean,\n    ): void {\n      // Strict mode words may be allowed as in `declare namespace N { const static: number; }`.\n      // And we have a type checker anyway, so don't bother having the parser do it.\n      if (!this.state.isAmbientContext) {\n        super.checkReservedWord(word, startLoc, checkKeywords, isBinding);\n      }\n    }\n\n    checkImportReflection(node: Undone<N.ImportDeclaration>) {\n      super.checkImportReflection(node);\n      if (node.module && node.importKind !== \"value\") {\n        this.raise(TSErrors.ImportReflectionHasImportType, {\n          at: node.specifiers[0].loc.start,\n        });\n      }\n    }\n\n    /*\n    Don't bother doing this check in TypeScript code because:\n    1. We may have a nested export statement with the same name:\n      export const x = 0;\n      export namespace N {\n        export const x = 1;\n      }\n    2. We have a type checker to warn us about this sort of thing.\n    */\n    checkDuplicateExports() {}\n\n    isPotentialImportPhase(isExport: boolean): boolean {\n      if (super.isPotentialImportPhase(isExport)) return true;\n      if (this.isContextual(tt._type)) {\n        const ch = this.lookaheadCharCode();\n        return isExport\n          ? ch === charCodes.leftCurlyBrace || ch === charCodes.asterisk\n          : ch !== charCodes.equalsTo;\n      }\n      return !isExport && this.isContextual(tt._typeof);\n    }\n\n    applyImportPhase(\n      node: Undone<N.ImportDeclaration | N.ExportNamedDeclaration>,\n      isExport: boolean,\n      phase: string | null,\n      loc?: Position,\n    ): void {\n      super.applyImportPhase(node, isExport, phase, loc);\n      if (isExport) {\n        (node as N.ExportNamedDeclaration).exportKind =\n          phase === \"type\" ? \"type\" : \"value\";\n      } else {\n        (node as N.ImportDeclaration).importKind =\n          phase === \"type\" || phase === \"typeof\" ? phase : \"value\";\n      }\n    }\n\n    parseImport(\n      node: Undone<N.ImportDeclaration | N.TsImportEqualsDeclaration>,\n    ): N.AnyImport {\n      if (this.match(tt.string)) {\n        node.importKind = \"value\";\n        return super.parseImport(node as Undone<N.ImportDeclaration>);\n      }\n\n      let importNode;\n      if (\n        tokenIsIdentifier(this.state.type) &&\n        this.lookaheadCharCode() === charCodes.equalsTo\n      ) {\n        node.importKind = \"value\";\n        return this.tsParseImportEqualsDeclaration(\n          node as Undone<N.TsImportEqualsDeclaration>,\n        );\n      } else if (this.isContextual(tt._type)) {\n        const maybeDefaultIdentifier = this.parseMaybeImportPhase(\n          node as Undone<N.ImportDeclaration>,\n          /* isExport */ false,\n        );\n        if (this.lookaheadCharCode() === charCodes.equalsTo) {\n          return this.tsParseImportEqualsDeclaration(\n            node as Undone<N.TsImportEqualsDeclaration>,\n            maybeDefaultIdentifier,\n          );\n        } else {\n          importNode = super.parseImportSpecifiersAndAfter(\n            node as Undone<N.ImportDeclaration>,\n            maybeDefaultIdentifier,\n          );\n        }\n      } else {\n        importNode = super.parseImport(node as Undone<N.ImportDeclaration>);\n      }\n\n      // `import type` can only be used on imports with named imports or with a\n      // default import - but not both\n      if (\n        importNode.importKind === \"type\" &&\n        // @ts-expect-error refine typings\n        importNode.specifiers.length > 1 &&\n        // @ts-expect-error refine typings\n        importNode.specifiers[0].type === \"ImportDefaultSpecifier\"\n      ) {\n        this.raise(TSErrors.TypeImportCannotSpecifyDefaultAndNamed, {\n          at: importNode,\n        });\n      }\n\n      return importNode;\n    }\n\n    parseExport(\n      node: Undone<N.Node>,\n      decorators: N.Decorator[] | null,\n    ): N.AnyExport {\n      if (this.match(tt._import)) {\n        // `export import A = B;`\n        this.next(); // eat `tt._import`\n        let maybeDefaultIdentifier: N.Identifier | null = null;\n        if (\n          this.isContextual(tt._type) &&\n          // We pass false here, because we are parsing an `import ... =`\n          this.isPotentialImportPhase(/* isExport */ false)\n        ) {\n          maybeDefaultIdentifier = this.parseMaybeImportPhase(\n            node as Undone<N.TsImportEqualsDeclaration>,\n            /* isExport */ false,\n          );\n        } else {\n          node.importKind = \"value\";\n        }\n        return this.tsParseImportEqualsDeclaration(\n          node as Undone<N.TsImportEqualsDeclaration>,\n          maybeDefaultIdentifier,\n          /* isExport */ true,\n        );\n      } else if (this.eat(tt.eq)) {\n        // `export = x;`\n        const assign = node as Undone<N.TsExportAssignment>;\n        assign.expression = super.parseExpression();\n        this.semicolon();\n        this.sawUnambiguousESM = true;\n        return this.finishNode(assign, \"TSExportAssignment\");\n      } else if (this.eatContextual(tt._as)) {\n        // `export as namespace A;`\n        const decl = node as Undone<N.TsNamespaceExportDeclaration>;\n        // See `parseNamespaceExportDeclaration` in TypeScript's own parser\n        this.expectContextual(tt._namespace);\n        decl.id = this.parseIdentifier();\n        this.semicolon();\n        return this.finishNode(decl, \"TSNamespaceExportDeclaration\");\n      } else {\n        return super.parseExport(\n          node as Undone<N.ExportAllDeclaration | N.ExportDefaultDeclaration>,\n          decorators,\n        );\n      }\n    }\n\n    isAbstractClass(): boolean {\n      return (\n        this.isContextual(tt._abstract) && this.lookahead().type === tt._class\n      );\n    }\n\n    parseExportDefaultExpression(): N.Expression | N.Declaration {\n      if (this.isAbstractClass()) {\n        const cls = this.startNode<N.Class>();\n        this.next(); // Skip \"abstract\"\n        cls.abstract = true;\n        return this.parseClass(cls, true, true);\n      }\n\n      // export default interface allowed in:\n      // https://github.com/Microsoft/TypeScript/pull/16040\n      if (this.match(tt._interface)) {\n        const result = this.tsParseInterfaceDeclaration(\n          this.startNode<N.TsInterfaceDeclaration>(),\n        );\n        if (result) return result;\n      }\n\n      return super.parseExportDefaultExpression();\n    }\n\n    parseVarStatement(\n      node: N.VariableDeclaration,\n      kind: \"var\" | \"let\" | \"const\" | \"using\",\n      allowMissingInitializer: boolean = false,\n    ) {\n      const { isAmbientContext } = this.state;\n      const declaration = super.parseVarStatement(\n        node,\n        kind,\n        allowMissingInitializer || isAmbientContext,\n      );\n\n      if (!isAmbientContext) return declaration;\n\n      for (const { id, init } of declaration.declarations) {\n        // Empty initializer is the easy case that we want.\n        if (!init) continue;\n\n        // var and let aren't ever allowed initializers.\n        if (kind !== \"const\" || !!id.typeAnnotation) {\n          this.raise(TSErrors.InitializerNotAllowedInAmbientContext, {\n            at: init,\n          });\n        } else if (\n          !isValidAmbientConstInitializer(init, this.hasPlugin(\"estree\"))\n        ) {\n          this.raise(\n            TSErrors.ConstInitiailizerMustBeStringOrNumericLiteralOrLiteralEnumReference,\n            { at: init },\n          );\n        }\n      }\n\n      return declaration;\n    }\n\n    parseStatementContent(\n      flags: ParseStatementFlag,\n      decorators?: N.Decorator[] | null,\n    ): N.Statement {\n      if (this.match(tt._const) && this.isLookaheadContextual(\"enum\")) {\n        const node = this.startNode<N.TsEnumDeclaration>();\n        this.expect(tt._const); // eat 'const'\n        return this.tsParseEnumDeclaration(node, { const: true });\n      }\n\n      if (this.isContextual(tt._enum)) {\n        return this.tsParseEnumDeclaration(\n          this.startNode<N.TsEnumDeclaration>(),\n        );\n      }\n\n      if (this.isContextual(tt._interface)) {\n        const result = this.tsParseInterfaceDeclaration(this.startNode());\n        if (result) return result;\n      }\n\n      return super.parseStatementContent(flags, decorators);\n    }\n\n    parseAccessModifier(): N.Accessibility | undefined | null {\n      return this.tsParseModifier([\"public\", \"protected\", \"private\"]);\n    }\n\n    tsHasSomeModifiers(member: any, modifiers: readonly TsModifier[]): boolean {\n      return modifiers.some(modifier => {\n        if (tsIsAccessModifier(modifier)) {\n          return member.accessibility === modifier;\n        }\n        return !!member[modifier];\n      });\n    }\n\n    tsIsStartOfStaticBlocks() {\n      return (\n        this.isContextual(tt._static) &&\n        this.lookaheadCharCode() === charCodes.leftCurlyBrace\n      );\n    }\n\n    parseClassMember(\n      classBody: N.ClassBody,\n      member: any,\n      state: N.ParseClassMemberState,\n    ): void {\n      const modifiers = [\n        \"declare\",\n        \"private\",\n        \"public\",\n        \"protected\",\n        \"override\",\n        \"abstract\",\n        \"readonly\",\n        \"static\",\n      ] as const;\n      this.tsParseModifiers(\n        {\n          allowedModifiers: modifiers,\n          disallowedModifiers: [\"in\", \"out\"],\n          stopOnStartOfClassStaticBlock: true,\n          errorTemplate: TSErrors.InvalidModifierOnTypeParameterPositions,\n        },\n        member,\n      );\n\n      const callParseClassMemberWithIsStatic = () => {\n        if (this.tsIsStartOfStaticBlocks()) {\n          this.next(); // eat \"static\"\n          this.next(); // eat \"{\"\n          if (this.tsHasSomeModifiers(member, modifiers)) {\n            this.raise(TSErrors.StaticBlockCannotHaveModifier, {\n              at: this.state.curPosition(),\n            });\n          }\n          super.parseClassStaticBlock(classBody, member as N.StaticBlock);\n        } else {\n          this.parseClassMemberWithIsStatic(\n            classBody,\n            member,\n            state,\n            !!member.static,\n          );\n        }\n      };\n      if (member.declare) {\n        this.tsInAmbientContext(callParseClassMemberWithIsStatic);\n      } else {\n        callParseClassMemberWithIsStatic();\n      }\n    }\n\n    parseClassMemberWithIsStatic(\n      classBody: N.ClassBody,\n      member: Undone<N.ClassMember | N.TsIndexSignature>,\n      state: N.ParseClassMemberState,\n      isStatic: boolean,\n    ): void {\n      const idx = this.tsTryParseIndexSignature(\n        member as Undone<N.TsIndexSignature>,\n      );\n      if (idx) {\n        classBody.body.push(idx);\n\n        if ((member as any).abstract) {\n          this.raise(TSErrors.IndexSignatureHasAbstract, { at: member });\n        }\n        if ((member as any).accessibility) {\n          this.raise(TSErrors.IndexSignatureHasAccessibility, {\n            at: member,\n            modifier: (member as any).accessibility,\n          });\n        }\n        if ((member as any).declare) {\n          this.raise(TSErrors.IndexSignatureHasDeclare, { at: member });\n        }\n        if ((member as any).override) {\n          this.raise(TSErrors.IndexSignatureHasOverride, { at: member });\n        }\n\n        return;\n      }\n\n      if (!this.state.inAbstractClass && (member as any).abstract) {\n        this.raise(TSErrors.NonAbstractClassHasAbstractMethod, {\n          at: member,\n        });\n      }\n\n      if ((member as any).override) {\n        if (!state.hadSuperClass) {\n          this.raise(TSErrors.OverrideNotInSubClass, { at: member });\n        }\n      }\n\n      /*:: invariant(member.type !== \"TSIndexSignature\") */\n\n      super.parseClassMemberWithIsStatic(\n        classBody,\n        member as Undone<N.ClassMember>,\n        state,\n        isStatic,\n      );\n    }\n\n    parsePostMemberNameModifiers(\n      methodOrProp: N.ClassMethod | N.ClassProperty | N.ClassPrivateProperty,\n    ): void {\n      const optional = this.eat(tt.question);\n      if (optional) methodOrProp.optional = true;\n\n      if ((methodOrProp as any).readonly && this.match(tt.parenL)) {\n        this.raise(TSErrors.ClassMethodHasReadonly, { at: methodOrProp });\n      }\n\n      if ((methodOrProp as any).declare && this.match(tt.parenL)) {\n        this.raise(TSErrors.ClassMethodHasDeclare, { at: methodOrProp });\n      }\n    }\n\n    // Note: The reason we do this in `parseExpressionStatement` and not `parseStatement`\n    // is that e.g. `type()` is valid JS, so we must try parsing that first.\n    // If it's really a type, we will parse `type` as the statement, and can correct it here\n    // by parsing the rest.\n    // @ts-expect-error plugin overrides interfaces\n    parseExpressionStatement(\n      node: Undone<N.ExpressionStatement>,\n      expr: N.Expression,\n      decorators: N.Decorator[] | null,\n    ): N.Statement {\n      const decl =\n        expr.type === \"Identifier\"\n          ? // @ts-expect-error refine typings\n            this.tsParseExpressionStatement(node, expr, decorators)\n          : undefined;\n      return decl || super.parseExpressionStatement(node, expr, decorators);\n    }\n\n    // export type\n    // Should be true for anything parsed by `tsTryParseExportDeclaration`.\n    shouldParseExportDeclaration(): boolean {\n      if (this.tsIsDeclarationStart()) return true;\n      return super.shouldParseExportDeclaration();\n    }\n\n    // An apparent conditional expression could actually be an optional parameter in an arrow function.\n    parseConditional(\n      expr: N.Expression,\n\n      startLoc: Position,\n      refExpressionErrors?: ExpressionErrors | null,\n    ): N.Expression {\n      // only do the expensive clone if there is a question mark\n      // and if we come from inside parens\n      if (!this.state.maybeInArrowParameters || !this.match(tt.question)) {\n        return super.parseConditional(\n          expr,\n\n          startLoc,\n          refExpressionErrors,\n        );\n      }\n\n      const result = this.tryParse(() =>\n        super.parseConditional(expr, startLoc),\n      );\n\n      if (!result.node) {\n        if (result.error) {\n          /*:: invariant(refExpressionErrors != null) */\n          super.setOptionalParametersError(refExpressionErrors, result.error);\n        }\n\n        return expr;\n      }\n      if (result.error) this.state = result.failState;\n      return result.node;\n    }\n\n    // Note: These \"type casts\" are *not* valid TS expressions.\n    // But we parse them here and change them when completing the arrow function.\n    parseParenItem(\n      node: N.Expression,\n\n      startLoc: Position,\n    ): N.Expression {\n      node = super.parseParenItem(node, startLoc);\n      if (this.eat(tt.question)) {\n        node.optional = true;\n        // Include questionmark in location of node\n        // Don't use this.finishNode() as otherwise we might process comments twice and\n        // include already consumed parens\n        this.resetEndLocation(node);\n      }\n\n      if (this.match(tt.colon)) {\n        const typeCastNode = this.startNodeAt<N.TsTypeCastExpression>(startLoc);\n        typeCastNode.expression = node;\n        typeCastNode.typeAnnotation = this.tsParseTypeAnnotation();\n\n        return this.finishNode(typeCastNode, \"TSTypeCastExpression\");\n      }\n\n      return node;\n    }\n\n    parseExportDeclaration(\n      node: N.ExportNamedDeclaration,\n    ): N.Declaration | undefined | null {\n      if (!this.state.isAmbientContext && this.isContextual(tt._declare)) {\n        return this.tsInAmbientContext(() => this.parseExportDeclaration(node));\n      }\n\n      // Store original location\n      const startLoc = this.state.startLoc;\n\n      const isDeclare = this.eatContextual(tt._declare);\n\n      if (\n        isDeclare &&\n        (this.isContextual(tt._declare) || !this.shouldParseExportDeclaration())\n      ) {\n        throw this.raise(TSErrors.ExpectedAmbientAfterExportDeclare, {\n          at: this.state.startLoc,\n        });\n      }\n\n      const isIdentifier = tokenIsIdentifier(this.state.type);\n      const declaration: N.Declaration | undefined | null =\n        (isIdentifier && this.tsTryParseExportDeclaration()) ||\n        super.parseExportDeclaration(node);\n\n      if (!declaration) return null;\n\n      if (\n        declaration.type === \"TSInterfaceDeclaration\" ||\n        declaration.type === \"TSTypeAliasDeclaration\" ||\n        isDeclare\n      ) {\n        node.exportKind = \"type\";\n      }\n\n      if (isDeclare) {\n        // Reset location to include `declare` in range\n        this.resetStartLocation(declaration, startLoc);\n\n        declaration.declare = true;\n      }\n\n      return declaration;\n    }\n\n    parseClassId(\n      node: N.Class,\n      isStatement: boolean,\n      optionalId?: boolean | null,\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n      bindingType?: BindingTypes,\n    ): void {\n      if ((!isStatement || optionalId) && this.isContextual(tt._implements)) {\n        return;\n      }\n\n      super.parseClassId(\n        node,\n        isStatement,\n        optionalId,\n        (node as any).declare ? BIND_TS_AMBIENT : BIND_CLASS,\n      );\n      const typeParameters = this.tsTryParseTypeParameters(\n        this.tsParseInOutConstModifiers,\n      );\n      if (typeParameters) node.typeParameters = typeParameters;\n    }\n\n    parseClassPropertyAnnotation(\n      node: N.ClassProperty | N.ClassPrivateProperty | N.ClassAccessorProperty,\n    ): void {\n      if (!node.optional) {\n        if (this.eat(tt.bang)) {\n          node.definite = true;\n        } else if (this.eat(tt.question)) {\n          node.optional = true;\n        }\n      }\n\n      const type = this.tsTryParseTypeAnnotation();\n      if (type) node.typeAnnotation = type;\n    }\n\n    parseClassProperty(node: N.ClassProperty): N.ClassProperty {\n      this.parseClassPropertyAnnotation(node);\n\n      if (\n        this.state.isAmbientContext &&\n        !(node.readonly && !node.typeAnnotation) &&\n        this.match(tt.eq)\n      ) {\n        this.raise(TSErrors.DeclareClassFieldHasInitializer, {\n          at: this.state.startLoc,\n        });\n      }\n      if (node.abstract && this.match(tt.eq)) {\n        const { key } = node;\n        this.raise(TSErrors.AbstractPropertyHasInitializer, {\n          at: this.state.startLoc,\n          propertyName:\n            key.type === \"Identifier\" && !node.computed\n              ? key.name\n              : `[${this.input.slice(key.start, key.end)}]`,\n        });\n      }\n\n      return super.parseClassProperty(node);\n    }\n\n    parseClassPrivateProperty(\n      node: N.ClassPrivateProperty,\n    ): N.ClassPrivateProperty {\n      // @ts-expect-error abstract may not index node\n      if (node.abstract) {\n        this.raise(TSErrors.PrivateElementHasAbstract, { at: node });\n      }\n\n      // @ts-expect-error accessibility may not index node\n      if (node.accessibility) {\n        this.raise(TSErrors.PrivateElementHasAccessibility, {\n          at: node,\n          // @ts-expect-error refine typings\n          modifier: node.accessibility,\n        });\n      }\n\n      this.parseClassPropertyAnnotation(node);\n      return super.parseClassPrivateProperty(node);\n    }\n\n    parseClassAccessorProperty(\n      node: N.ClassAccessorProperty,\n    ): N.ClassAccessorProperty {\n      this.parseClassPropertyAnnotation(node);\n      if (node.optional) {\n        this.raise(TSErrors.AccessorCannotBeOptional, { at: node });\n      }\n      return super.parseClassAccessorProperty(node);\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      const typeParameters = this.tsTryParseTypeParameters(\n        this.tsParseConstModifier,\n      );\n      if (typeParameters && isConstructor) {\n        this.raise(TSErrors.ConstructorHasTypeParameters, {\n          at: typeParameters,\n        });\n      }\n\n      // @ts-expect-error declare does not exist in ClassMethod\n      const { declare = false, kind } = method;\n\n      if (declare && (kind === \"get\" || kind === \"set\")) {\n        this.raise(TSErrors.DeclareAccessor, { at: method, kind });\n      }\n      if (typeParameters) method.typeParameters = typeParameters;\n      super.pushClassMethod(\n        classBody,\n        method,\n        isGenerator,\n        isAsync,\n        isConstructor,\n        allowsDirectSuper,\n      );\n    }\n\n    pushClassPrivateMethod(\n      classBody: N.ClassBody,\n      method: N.ClassPrivateMethod,\n      isGenerator: boolean,\n      isAsync: boolean,\n    ): void {\n      const typeParameters = this.tsTryParseTypeParameters(\n        this.tsParseConstModifier,\n      );\n      if (typeParameters) method.typeParameters = typeParameters;\n      super.pushClassPrivateMethod(classBody, method, isGenerator, isAsync);\n    }\n\n    declareClassPrivateMethodInScope(\n      node: N.ClassPrivateMethod | N.EstreeMethodDefinition | N.TSDeclareMethod,\n      kind: number,\n    ) {\n      if (node.type === \"TSDeclareMethod\") return;\n      // This happens when using the \"estree\" plugin.\n      if (node.type === \"MethodDefinition\" && !node.value.body) return;\n\n      super.declareClassPrivateMethodInScope(node, kind);\n    }\n\n    parseClassSuper(node: N.Class): void {\n      super.parseClassSuper(node);\n      // handle `extends f<<T>\n      if (node.superClass && (this.match(tt.lt) || this.match(tt.bitShiftL))) {\n        // @ts-expect-error refine typings\n        node.superTypeParameters = this.tsParseTypeArgumentsInExpression();\n      }\n      if (this.eatContextual(tt._implements)) {\n        node.implements = this.tsParseHeritageClause(\"implements\");\n      }\n    }\n\n    parseObjPropValue(\n      prop: Undone<N.ObjectMethod | N.ObjectProperty>,\n      startLoc: Position | undefined | null,\n      isGenerator: boolean,\n      isAsync: boolean,\n      isPattern: boolean,\n      isAccessor: boolean,\n      refExpressionErrors?: ExpressionErrors | null,\n    ) {\n      const typeParameters = this.tsTryParseTypeParameters(\n        this.tsParseConstModifier,\n      );\n      if (typeParameters) prop.typeParameters = typeParameters;\n\n      return super.parseObjPropValue(\n        prop,\n\n        startLoc,\n        isGenerator,\n        isAsync,\n        isPattern,\n        isAccessor,\n        refExpressionErrors,\n      );\n    }\n\n    parseFunctionParams(node: N.Function, isConstructor: boolean): void {\n      const typeParameters = this.tsTryParseTypeParameters(\n        this.tsParseConstModifier,\n      );\n      if (typeParameters) node.typeParameters = typeParameters;\n      super.parseFunctionParams(node, isConstructor);\n    }\n\n    // `let x: number;`\n    parseVarId(\n      decl: N.VariableDeclarator,\n      kind: \"var\" | \"let\" | \"const\" | \"using\",\n    ): void {\n      super.parseVarId(decl, kind);\n      if (\n        decl.id.type === \"Identifier\" &&\n        !this.hasPrecedingLineBreak() &&\n        this.eat(tt.bang)\n      ) {\n        decl.definite = true;\n      }\n\n      const type = this.tsTryParseTypeAnnotation();\n      if (type) {\n        decl.id.typeAnnotation = type;\n        this.resetEndLocation(decl.id); // set end position to end of type\n      }\n    }\n\n    // parse the return type of an async arrow function - let foo = (async (): number => {});\n    parseAsyncArrowFromCallExpression(\n      node: N.ArrowFunctionExpression,\n      call: N.CallExpression,\n    ): N.ArrowFunctionExpression {\n      if (this.match(tt.colon)) {\n        node.returnType = this.tsParseTypeAnnotation();\n      }\n      return super.parseAsyncArrowFromCallExpression(node, call);\n    }\n\n    parseMaybeAssign(\n      refExpressionErrors?: ExpressionErrors | null,\n      afterLeftParse?: Function,\n    ): N.Expression {\n      // Note: When the JSX plugin is on, type assertions (`<T> x`) aren't valid syntax.\n\n      let state: State | undefined | null;\n      let jsx;\n      let typeCast;\n\n      if (\n        this.hasPlugin(\"jsx\") &&\n        (this.match(tt.jsxTagStart) || this.match(tt.lt))\n      ) {\n        // Prefer to parse JSX if possible. But may be an arrow fn.\n        state = this.state.clone();\n\n        jsx = this.tryParse(\n          () => super.parseMaybeAssign(refExpressionErrors, afterLeftParse),\n          state,\n        );\n\n        /*:: invariant(!jsx.aborted) */\n        /*:: invariant(jsx.node != null) */\n        if (!jsx.error) return jsx.node;\n\n        // Remove `tc.j_expr` or `tc.j_oTag` from context added\n        // by parsing `jsxTagStart` to stop the JSX plugin from\n        // messing with the tokens\n        const { context } = this.state;\n        const currentContext = context[context.length - 1];\n        if (currentContext === tc.j_oTag || currentContext === tc.j_expr) {\n          context.pop();\n        }\n      }\n\n      if (!jsx?.error && !this.match(tt.lt)) {\n        return super.parseMaybeAssign(refExpressionErrors, afterLeftParse);\n      }\n\n      // Either way, we're looking at a '<': tt.jsxTagStart or relational.\n\n      // If the state was cloned in the JSX parsing branch above but there\n      // have been any error in the tryParse call, this.state is set to state\n      // so we still need to clone it.\n      if (!state || state === this.state) state = this.state.clone();\n\n      let typeParameters: N.TsTypeParameterDeclaration | undefined | null;\n      const arrow = this.tryParse(abort => {\n        // This is similar to TypeScript's `tryParseParenthesizedArrowFunctionExpression`.\n        typeParameters = this.tsParseTypeParameters(this.tsParseConstModifier);\n        const expr = super.parseMaybeAssign(\n          refExpressionErrors,\n          afterLeftParse,\n        );\n\n        if (\n          expr.type !== \"ArrowFunctionExpression\" ||\n          expr.extra?.parenthesized\n        ) {\n          abort();\n        }\n\n        // Correct TypeScript code should have at least 1 type parameter, but don't crash on bad code.\n        if (typeParameters?.params.length !== 0) {\n          this.resetStartLocationFromNode(expr, typeParameters);\n        }\n        expr.typeParameters = typeParameters;\n\n        if (process.env.BABEL_8_BREAKING) {\n          if (\n            this.hasPlugin(\"jsx\") &&\n            expr.typeParameters.params.length === 1 &&\n            !expr.typeParameters.extra?.trailingComma\n          ) {\n            // report error if single type parameter used without trailing comma.\n            const parameter = expr.typeParameters.params[0];\n            if (!parameter.constraint) {\n              // A single type parameter must either have constraints\n              // or a trailing comma, otherwise it's ambiguous with JSX.\n              this.raise(TSErrors.SingleTypeParameterWithoutTrailingComma, {\n                at: createPositionWithColumnOffset(parameter.loc.end, 1),\n                typeParameterName: parameter.name.name,\n              });\n            }\n          }\n        }\n\n        return expr;\n      }, state);\n\n      /*:: invariant(arrow.node != null) */\n      if (!arrow.error && !arrow.aborted) {\n        // This error is reported outside of the this.tryParse call so that\n        // in case of <T>(x) => 2, we don't consider <T>(x) as a type assertion\n        // because of this error.\n        if (typeParameters) this.reportReservedArrowTypeParam(typeParameters);\n        // @ts-expect-error refine typings\n        return arrow.node;\n      }\n\n      if (!jsx) {\n        // Try parsing a type cast instead of an arrow function.\n        // This will never happen outside of JSX.\n        // (Because in JSX the '<' should be a jsxTagStart and not a relational.\n        assert(!this.hasPlugin(\"jsx\"));\n\n        // This will start with a type assertion (via parseMaybeUnary).\n        // But don't directly call `this.tsParseTypeAssertion` because we want to handle any binary after it.\n        typeCast = this.tryParse(\n          () => super.parseMaybeAssign(refExpressionErrors, afterLeftParse),\n          state,\n        );\n        /*:: invariant(!typeCast.aborted) */\n        /*:: invariant(typeCast.node != null) */\n        if (!typeCast.error) return typeCast.node;\n      }\n\n      if (jsx?.node) {\n        /*:: invariant(jsx.failState) */\n        this.state = jsx.failState;\n        return jsx.node;\n      }\n\n      if (arrow.node) {\n        /*:: invariant(arrow.failState) */\n        this.state = arrow.failState;\n        if (typeParameters) this.reportReservedArrowTypeParam(typeParameters);\n        // @ts-expect-error refine typings\n        return arrow.node;\n      }\n\n      if (typeCast?.node) {\n        /*:: invariant(typeCast.failState) */\n        this.state = typeCast.failState;\n        return typeCast.node;\n      }\n\n      throw jsx?.error || arrow.error || typeCast?.error;\n    }\n\n    reportReservedArrowTypeParam(node: any) {\n      if (\n        node.params.length === 1 &&\n        !node.params[0].constraint &&\n        !node.extra?.trailingComma &&\n        this.getPluginOption(\"typescript\", \"disallowAmbiguousJSXLike\")\n      ) {\n        this.raise(TSErrors.ReservedArrowTypeParam, { at: node });\n      }\n    }\n\n    // Handle type assertions\n    parseMaybeUnary(\n      refExpressionErrors?: ExpressionErrors | null,\n      sawUnary?: boolean,\n    ): N.Expression {\n      if (!this.hasPlugin(\"jsx\") && this.match(tt.lt)) {\n        return this.tsParseTypeAssertion();\n      }\n      return super.parseMaybeUnary(refExpressionErrors, sawUnary);\n    }\n\n    parseArrow(\n      node: Undone<N.ArrowFunctionExpression>,\n    ): Undone<N.ArrowFunctionExpression> | undefined | null {\n      if (this.match(tt.colon)) {\n        // This is different from how the TS parser does it.\n        // TS uses lookahead. The Babel Parser parses it as a parenthesized expression and converts.\n\n        const result = this.tryParse(abort => {\n          const returnType = this.tsParseTypeOrTypePredicateAnnotation(\n            tt.colon,\n          );\n          if (this.canInsertSemicolon() || !this.match(tt.arrow)) abort();\n          return returnType;\n        });\n\n        if (result.aborted) return;\n\n        if (!result.thrown) {\n          if (result.error) this.state = result.failState;\n          // @ts-expect-error refine typings\n          node.returnType = result.node;\n        }\n      }\n\n      return super.parseArrow(node);\n    }\n\n    // Allow type annotations inside of a parameter list.\n    parseAssignableListItemTypes(\n      param: N.Pattern,\n      flags: ParseBindingListFlags,\n    ) {\n      if (!(flags & ParseBindingListFlags.IS_FUNCTION_PARAMS)) return param;\n\n      if (this.eat(tt.question)) {\n        (param as any as N.Identifier).optional = true;\n      }\n      const type = this.tsTryParseTypeAnnotation();\n      if (type) param.typeAnnotation = type;\n      this.resetEndLocation(param);\n\n      return param;\n    }\n\n    isAssignable(node: N.Node, isBinding?: boolean): boolean {\n      switch (node.type) {\n        case \"TSTypeCastExpression\":\n          return this.isAssignable(node.expression, isBinding);\n        case \"TSParameterProperty\":\n          return true;\n        default:\n          return super.isAssignable(node, isBinding);\n      }\n    }\n\n    toAssignable(node: N.Node, isLHS: boolean = false): void {\n      switch (node.type) {\n        case \"ParenthesizedExpression\":\n          this.toAssignableParenthesizedExpression(node, isLHS);\n          break;\n        case \"TSAsExpression\":\n        case \"TSSatisfiesExpression\":\n        case \"TSNonNullExpression\":\n        case \"TSTypeAssertion\":\n          if (isLHS) {\n            this.expressionScope.recordArrowParameterBindingError(\n              TSErrors.UnexpectedTypeCastInParameter,\n              { at: node },\n            );\n          } else {\n            this.raise(TSErrors.UnexpectedTypeCastInParameter, { at: node });\n          }\n          this.toAssignable(node.expression, isLHS);\n          break;\n        case \"AssignmentExpression\":\n          if (!isLHS && node.left.type === \"TSTypeCastExpression\") {\n            node.left = this.typeCastToParameter(node.left);\n          }\n        /* fall through */\n        default:\n          super.toAssignable(node, isLHS);\n      }\n    }\n\n    toAssignableParenthesizedExpression(node: N.Node, isLHS: boolean): void {\n      switch (node.expression.type) {\n        case \"TSAsExpression\":\n        case \"TSSatisfiesExpression\":\n        case \"TSNonNullExpression\":\n        case \"TSTypeAssertion\":\n        case \"ParenthesizedExpression\":\n          this.toAssignable(node.expression, isLHS);\n          break;\n        default:\n          super.toAssignable(node, isLHS);\n      }\n    }\n\n    checkToRestConversion(node: N.Node, allowPattern: boolean): void {\n      switch (node.type) {\n        case \"TSAsExpression\":\n        case \"TSSatisfiesExpression\":\n        case \"TSTypeAssertion\":\n        case \"TSNonNullExpression\":\n          this.checkToRestConversion(node.expression, false);\n          break;\n        default:\n          super.checkToRestConversion(node, allowPattern);\n      }\n    }\n\n    // @ts-expect-error plugin overrides interfaces\n    isValidLVal(\n      type:\n        | \"TSTypeCastExpression\"\n        | \"TSParameterProperty\"\n        | \"TSNonNullExpression\"\n        | \"TSAsExpression\"\n        | \"TSSatisfiesExpression\"\n        | \"TSTypeAssertion\",\n      isUnparenthesizedInAssign: boolean,\n      binding: BindingTypes,\n    ) {\n      return (\n        getOwn(\n          {\n            // Allow \"typecasts\" to appear on the left of assignment expressions,\n            // because it may be in an arrow function.\n            // e.g. `const f = (foo: number = 0) => foo;`\n            TSTypeCastExpression: true,\n            TSParameterProperty: \"parameter\",\n            TSNonNullExpression: \"expression\",\n            TSAsExpression: (binding !== BIND_NONE ||\n              !isUnparenthesizedInAssign) && [\"expression\", true],\n            TSSatisfiesExpression: (binding !== BIND_NONE ||\n              !isUnparenthesizedInAssign) && [\"expression\", true],\n            TSTypeAssertion: (binding !== BIND_NONE ||\n              !isUnparenthesizedInAssign) && [\"expression\", true],\n          },\n          type,\n        ) || super.isValidLVal(type, isUnparenthesizedInAssign, binding)\n      );\n    }\n\n    parseBindingAtom(): N.Pattern {\n      if (this.state.type === tt._this) {\n        return this.parseIdentifier(/* liberal */ true);\n      }\n      return super.parseBindingAtom();\n    }\n\n    parseMaybeDecoratorArguments(expr: N.Expression): N.Expression {\n      // handles `@f<<T>`\n      if (this.match(tt.lt) || this.match(tt.bitShiftL)) {\n        const typeArguments = this.tsParseTypeArgumentsInExpression();\n\n        if (this.match(tt.parenL)) {\n          const call = super.parseMaybeDecoratorArguments(expr);\n          call.typeParameters = typeArguments;\n          return call;\n        }\n\n        this.unexpected(null, tt.parenL);\n      }\n\n      return super.parseMaybeDecoratorArguments(expr);\n    }\n\n    checkCommaAfterRest(\n      close: (typeof charCodes)[keyof typeof charCodes],\n    ): boolean {\n      if (\n        this.state.isAmbientContext &&\n        this.match(tt.comma) &&\n        this.lookaheadCharCode() === close\n      ) {\n        this.next();\n        return false;\n      }\n      return super.checkCommaAfterRest(close);\n    }\n\n    // === === === === === === === === === === === === === === === ===\n    // Note: All below methods are duplicates of something in flow.js.\n    // Not sure what the best way to combine these is.\n    // === === === === === === === === === === === === === === === ===\n\n    isClassMethod(): boolean {\n      return this.match(tt.lt) || super.isClassMethod();\n    }\n\n    isClassProperty(): boolean {\n      return (\n        this.match(tt.bang) || this.match(tt.colon) || super.isClassProperty()\n      );\n    }\n\n    parseMaybeDefault(\n      startLoc?: Position | null,\n      left?: Pattern | null,\n    ): N.Pattern {\n      const node = super.parseMaybeDefault(startLoc, left);\n\n      if (\n        node.type === \"AssignmentPattern\" &&\n        node.typeAnnotation &&\n        node.right.start < node.typeAnnotation.start\n      ) {\n        this.raise(TSErrors.TypeAnnotationAfterAssign, {\n          at: node.typeAnnotation,\n        });\n      }\n\n      return node;\n    }\n\n    // ensure that inside types, we bypass the jsx parser plugin\n    getTokenFromCode(code: number): void {\n      if (this.state.inType) {\n        if (code === charCodes.greaterThan) {\n          this.finishOp(tt.gt, 1);\n          return;\n        }\n        if (code === charCodes.lessThan) {\n          this.finishOp(tt.lt, 1);\n          return;\n        }\n      }\n      super.getTokenFromCode(code);\n    }\n\n    // used after we have finished parsing types\n    reScan_lt_gt() {\n      const { type } = this.state;\n      if (type === tt.lt) {\n        this.state.pos -= 1;\n        this.readToken_lt();\n      } else if (type === tt.gt) {\n        this.state.pos -= 1;\n        this.readToken_gt();\n      }\n    }\n\n    reScan_lt() {\n      const { type } = this.state;\n      if (type === tt.bitShiftL) {\n        this.state.pos -= 2;\n        this.finishOp(tt.lt, 1);\n        return tt.lt;\n      }\n      return type;\n    }\n\n    toAssignableList(\n      exprList: Expression[],\n      trailingCommaLoc: Position | undefined | null,\n      isLHS: boolean,\n    ): void {\n      for (let i = 0; i < exprList.length; i++) {\n        const expr = exprList[i];\n        if (expr?.type === \"TSTypeCastExpression\") {\n          exprList[i] = this.typeCastToParameter(\n            expr as N.TsTypeCastExpression,\n          );\n        }\n      }\n      super.toAssignableList(exprList, trailingCommaLoc, isLHS);\n    }\n\n    typeCastToParameter(node: N.TsTypeCastExpression): N.Node {\n      node.expression.typeAnnotation = node.typeAnnotation;\n\n      this.resetEndLocation(node.expression, node.typeAnnotation.loc.end);\n\n      return node.expression;\n    }\n\n    shouldParseArrow(params: Array<N.Node>) {\n      if (this.match(tt.colon)) {\n        return params.every(expr => this.isAssignable(expr, true));\n      }\n      return super.shouldParseArrow(params);\n    }\n\n    shouldParseAsyncArrow(): boolean {\n      return this.match(tt.colon) || super.shouldParseAsyncArrow();\n    }\n\n    canHaveLeadingDecorator() {\n      // Avoid unnecessary lookahead in checking for abstract class unless needed!\n      return super.canHaveLeadingDecorator() || this.isAbstractClass();\n    }\n\n    jsxParseOpeningElementAfterName(\n      node: N.JSXOpeningElement,\n    ): N.JSXOpeningElement {\n      // handles `<Component<<T>`\n      if (this.match(tt.lt) || this.match(tt.bitShiftL)) {\n        const typeArguments = this.tsTryParseAndCatch(() =>\n          // @ts-expect-error: refine typings\n          this.tsParseTypeArgumentsInExpression(),\n        );\n        // @ts-expect-error: refine typings\n        if (typeArguments) node.typeParameters = typeArguments;\n      }\n      return super.jsxParseOpeningElementAfterName(node);\n    }\n\n    getGetterSetterExpectedParamCount(\n      method: N.ObjectMethod | N.ClassMethod,\n    ): number {\n      const baseCount = super.getGetterSetterExpectedParamCount(method);\n      const params = this.getObjectOrClassMethodParams(method);\n      const firstParam = params[0];\n      const hasContextParam = firstParam && this.isThisParam(firstParam);\n\n      return hasContextParam ? baseCount + 1 : baseCount;\n    }\n\n    parseCatchClauseParam(): N.Pattern {\n      const param = super.parseCatchClauseParam();\n      const type = this.tsTryParseTypeAnnotation();\n\n      if (type) {\n        param.typeAnnotation = type;\n        this.resetEndLocation(param);\n      }\n\n      return param;\n    }\n\n    tsInAmbientContext<T>(cb: () => T): T {\n      const oldIsAmbientContext = this.state.isAmbientContext;\n      this.state.isAmbientContext = true;\n      try {\n        return cb();\n      } finally {\n        this.state.isAmbientContext = oldIsAmbientContext;\n      }\n    }\n\n    parseClass<T extends N.Class>(\n      node: Undone<T>,\n      isStatement: boolean,\n      optionalId?: boolean,\n    ): T {\n      const oldInAbstractClass = this.state.inAbstractClass;\n      this.state.inAbstractClass = !!(node as any).abstract;\n      try {\n        return super.parseClass(node, isStatement, optionalId);\n      } finally {\n        this.state.inAbstractClass = oldInAbstractClass;\n      }\n    }\n\n    tsParseAbstractDeclaration(\n      node: any,\n      decorators: N.Decorator[] | null,\n    ): N.ClassDeclaration | N.TsInterfaceDeclaration | undefined | null {\n      if (this.match(tt._class)) {\n        node.abstract = true;\n        return this.maybeTakeDecorators(\n          decorators,\n          this.parseClass<N.ClassDeclaration>(\n            node as N.ClassDeclaration,\n            /* isStatement */ true,\n            /* optionalId */ false,\n          ),\n        );\n      } else if (this.isContextual(tt._interface)) {\n        // for invalid abstract interface\n\n        // To avoid\n        //   abstract interface\n        //   Foo {}\n        if (!this.hasFollowingLineBreak()) {\n          node.abstract = true;\n          this.raise(TSErrors.NonClassMethodPropertyHasAbstractModifer, {\n            at: node,\n          });\n          return this.tsParseInterfaceDeclaration(\n            node as N.TsInterfaceDeclaration,\n          );\n        }\n      } else {\n        this.unexpected(null, tt._class);\n      }\n    }\n\n    parseMethod<\n      T extends N.ObjectMethod | N.ClassMethod | N.ClassPrivateMethod,\n    >(\n      node: Undone<T>,\n      isGenerator: boolean,\n      isAsync: boolean,\n      isConstructor: boolean,\n      allowDirectSuper: boolean,\n      type: T[\"type\"],\n      inClassScope?: boolean,\n    ) {\n      const method = super.parseMethod<T>(\n        node,\n        isGenerator,\n        isAsync,\n        isConstructor,\n        allowDirectSuper,\n        type,\n        inClassScope,\n      );\n      // @ts-expect-error todo(flow->ts) property not defined for all types in union\n      if (method.abstract) {\n        const hasBody = this.hasPlugin(\"estree\")\n          ? // @ts-expect-error estree typings\n            !!method.value.body\n          : !!method.body;\n        if (hasBody) {\n          const { key } = method;\n          this.raise(TSErrors.AbstractMethodHasImplementation, {\n            at: method,\n            methodName:\n              key.type === \"Identifier\" && !method.computed\n                ? key.name\n                : `[${this.input.slice(key.start, key.end)}]`,\n          });\n        }\n      }\n      return method;\n    }\n\n    tsParseTypeParameterName(): N.Identifier | string {\n      const typeName: N.Identifier = this.parseIdentifier();\n      return process.env.BABEL_8_BREAKING ? typeName : typeName.name;\n    }\n\n    shouldParseAsAmbientContext(): boolean {\n      return !!this.getPluginOption(\"typescript\", \"dts\");\n    }\n\n    parse() {\n      if (this.shouldParseAsAmbientContext()) {\n        this.state.isAmbientContext = true;\n      }\n      return super.parse();\n    }\n\n    getExpression() {\n      if (this.shouldParseAsAmbientContext()) {\n        this.state.isAmbientContext = true;\n      }\n      return super.getExpression();\n    }\n\n    parseExportSpecifier(\n      node: Undone<N.ExportSpecifier>,\n      isString: boolean,\n      isInTypeExport: boolean,\n      isMaybeTypeOnly: boolean,\n    ) {\n      if (!isString && isMaybeTypeOnly) {\n        this.parseTypeOnlyImportExportSpecifier(\n          node,\n          /* isImport */ false,\n          isInTypeExport,\n        );\n        return this.finishNode<N.ExportSpecifier>(node, \"ExportSpecifier\");\n      }\n      node.exportKind = \"value\";\n      return super.parseExportSpecifier(\n        node,\n        isString,\n        isInTypeExport,\n        isMaybeTypeOnly,\n      );\n    }\n\n    parseImportSpecifier(\n      specifier: Undone<N.ImportSpecifier>,\n      importedIsString: boolean,\n      isInTypeOnlyImport: boolean,\n      isMaybeTypeOnly: boolean,\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n      bindingType: BindingTypes | undefined,\n    ): N.ImportSpecifier {\n      if (!importedIsString && isMaybeTypeOnly) {\n        this.parseTypeOnlyImportExportSpecifier(\n          specifier,\n          /* isImport */ true,\n          isInTypeOnlyImport,\n        );\n        return this.finishNode<N.ImportSpecifier>(specifier, \"ImportSpecifier\");\n      }\n      specifier.importKind = \"value\";\n      return super.parseImportSpecifier(\n        specifier,\n        importedIsString,\n        isInTypeOnlyImport,\n        isMaybeTypeOnly,\n        isInTypeOnlyImport ? BIND_TS_TYPE_IMPORT : BIND_FLAGS_TS_IMPORT,\n      );\n    }\n\n    parseTypeOnlyImportExportSpecifier(\n      node: any,\n      isImport: boolean,\n      isInTypeOnlyImportExport: boolean,\n    ): void {\n      const leftOfAsKey = isImport ? \"imported\" : \"local\";\n      const rightOfAsKey = isImport ? \"local\" : \"exported\";\n\n      let leftOfAs = node[leftOfAsKey];\n      let rightOfAs;\n\n      let hasTypeSpecifier = false;\n      let canParseAsKeyword = true;\n\n      const loc = leftOfAs.loc.start;\n\n      // https://github.com/microsoft/TypeScript/blob/fc4f9d83d5939047aa6bb2a43965c6e9bbfbc35b/src/compiler/parser.ts#L7411-L7456\n      // import { type } from \"mod\";          - hasTypeSpecifier: false, leftOfAs: type\n      // import { type as } from \"mod\";       - hasTypeSpecifier: true,  leftOfAs: as\n      // import { type as as } from \"mod\";    - hasTypeSpecifier: false, leftOfAs: type, rightOfAs: as\n      // import { type as as as } from \"mod\"; - hasTypeSpecifier: true,  leftOfAs: as,   rightOfAs: as\n      if (this.isContextual(tt._as)) {\n        // { type as ...? }\n        const firstAs = this.parseIdentifier();\n        if (this.isContextual(tt._as)) {\n          // { type as as ...? }\n          const secondAs = this.parseIdentifier();\n          if (tokenIsKeywordOrIdentifier(this.state.type)) {\n            // { type as as something }\n            hasTypeSpecifier = true;\n            leftOfAs = firstAs;\n            rightOfAs = isImport\n              ? this.parseIdentifier()\n              : this.parseModuleExportName();\n            canParseAsKeyword = false;\n          } else {\n            // { type as as }\n            rightOfAs = secondAs;\n            canParseAsKeyword = false;\n          }\n        } else if (tokenIsKeywordOrIdentifier(this.state.type)) {\n          // { type as something }\n          canParseAsKeyword = false;\n          rightOfAs = isImport\n            ? this.parseIdentifier()\n            : this.parseModuleExportName();\n        } else {\n          // { type as }\n          hasTypeSpecifier = true;\n          leftOfAs = firstAs;\n        }\n      } else if (tokenIsKeywordOrIdentifier(this.state.type)) {\n        // { type something ...? }\n        hasTypeSpecifier = true;\n        if (isImport) {\n          leftOfAs = this.parseIdentifier(true);\n          if (!this.isContextual(tt._as)) {\n            this.checkReservedWord(\n              leftOfAs.name,\n              leftOfAs.loc.start,\n              true,\n              true,\n            );\n          }\n        } else {\n          leftOfAs = this.parseModuleExportName();\n        }\n      }\n      if (hasTypeSpecifier && isInTypeOnlyImportExport) {\n        this.raise(\n          isImport\n            ? TSErrors.TypeModifierIsUsedInTypeImports\n            : TSErrors.TypeModifierIsUsedInTypeExports,\n          { at: loc },\n        );\n      }\n\n      node[leftOfAsKey] = leftOfAs;\n      node[rightOfAsKey] = rightOfAs;\n\n      const kindKey = isImport ? \"importKind\" : \"exportKind\";\n      node[kindKey] = hasTypeSpecifier ? \"type\" : \"value\";\n\n      if (canParseAsKeyword && this.eatContextual(tt._as)) {\n        node[rightOfAsKey] = isImport\n          ? this.parseIdentifier()\n          : this.parseModuleExportName();\n      }\n      if (!node[rightOfAsKey]) {\n        node[rightOfAsKey] = cloneIdentifier(node[leftOfAsKey]);\n      }\n      if (isImport) {\n        this.checkIdentifier(\n          node[rightOfAsKey],\n          hasTypeSpecifier ? BIND_TS_TYPE_IMPORT : BIND_FLAGS_TS_IMPORT,\n        );\n      }\n    }\n  };\n\nfunction isPossiblyLiteralEnum(expression: N.Expression): boolean {\n  if (expression.type !== \"MemberExpression\") return false;\n\n  const { computed, property } = expression;\n\n  if (\n    computed &&\n    property.type !== \"StringLiteral\" &&\n    (property.type !== \"TemplateLiteral\" || property.expressions.length > 0)\n  ) {\n    return false;\n  }\n\n  return isUncomputedMemberExpressionChain(expression.object);\n}\n\n// If a const declaration has no type annotation and is initialized to\n// a string literal, numeric literal, or enum reference, then it is\n// allowed. In an ideal world, we'd check whether init was *actually* an\n// enum reference, but we allow anything that \"could be\" a literal enum\n// in `isPossiblyLiteralEnum` since we don't have all the information\n// that the typescript compiler has.\nfunction isValidAmbientConstInitializer(\n  expression: N.Expression,\n  estree: boolean,\n): boolean {\n  const { type } = expression;\n  if (expression.extra?.parenthesized) {\n    return false;\n  }\n  if (estree) {\n    if (type === \"Literal\") {\n      const { value } = expression;\n      if (typeof value === \"string\" || typeof value === \"boolean\") {\n        return true;\n      }\n    }\n  } else {\n    if (type === \"StringLiteral\" || type === \"BooleanLiteral\") {\n      return true;\n    }\n  }\n  if (isNumber(expression, estree) || isNegativeNumber(expression, estree)) {\n    return true;\n  }\n  if (type === \"TemplateLiteral\" && expression.expressions.length === 0) {\n    return true;\n  }\n  if (isPossiblyLiteralEnum(expression)) {\n    return true;\n  }\n  return false;\n}\n\nfunction isNumber(expression: N.Expression, estree: boolean): boolean {\n  if (estree) {\n    return (\n      expression.type === \"Literal\" &&\n      (typeof expression.value === \"number\" || \"bigint\" in expression)\n    );\n  }\n  return (\n    expression.type === \"NumericLiteral\" || expression.type === \"BigIntLiteral\"\n  );\n}\n\nfunction isNegativeNumber(expression: N.Expression, estree: boolean): boolean {\n  if (expression.type === \"UnaryExpression\") {\n    const { operator, argument } = expression as N.UnaryExpression;\n    if (operator === \"-\" && isNumber(argument, estree)) {\n      return true;\n    }\n  }\n  return false;\n}\n\nfunction isUncomputedMemberExpressionChain(expression: N.Expression): boolean {\n  if (expression.type === \"Identifier\") return true;\n  if (expression.type !== \"MemberExpression\" || expression.computed) {\n    return false;\n  }\n\n  return isUncomputedMemberExpressionChain(expression.object);\n}\n","import * as charCodes from \"charcodes\";\n\nimport { tokenLabelName, tt } from \"../tokenizer/types\";\nimport type Parser from \"../parser\";\nimport type * as N from \"../types\";\nimport { ParseErrorEnum } from \"../parse-error\";\nimport type { Undone } from \"../parser/node\";\nimport type { ExpressionErrors } from \"../parser/util\";\nimport type { BindingTypes } from \"../util/scopeflags\";\nimport type { Position } from \"../util/location\";\n\ntype PossiblePlaceholders = {\n  Identifier: N.Identifier;\n  StringLiteral: N.StringLiteral;\n  Expression: N.Expression;\n  Statement: N.Statement;\n  Declaration: N.Declaration;\n  BlockStatement: N.BlockStatement;\n  ClassBody: N.ClassBody;\n  Pattern: N.Pattern;\n};\nexport type PlaceholderTypes = keyof PossiblePlaceholders;\n\ntype NodeOf<T extends keyof PossiblePlaceholders> = PossiblePlaceholders[T];\n// todo: when there  is proper union type for Node\n// type NodeOf<T extends PlaceholderTypes> = Extract<N.Node, { type: T }>;\n\n// todo: Placeholder<T> breaks everything, because its type is incompatible with\n// the substituted nodes.\ntype MaybePlaceholder<T extends PlaceholderTypes> = NodeOf<T>; // | Placeholder<T>\n\n/* eslint sort-keys: \"error\" */\nconst PlaceholderErrors = ParseErrorEnum`placeholders`({\n  ClassNameIsRequired: \"A class name is required.\",\n  UnexpectedSpace: \"Unexpected space in placeholder.\",\n});\n\n/* eslint-disable sort-keys */\n\nexport default (superClass: typeof Parser) =>\n  class PlaceholdersParserMixin extends superClass implements Parser {\n    parsePlaceholder<T extends PlaceholderTypes>(\n      expectedNode: T,\n    ): /*?N.Placeholder<T>*/ MaybePlaceholder<T> | undefined | null {\n      if (this.match(tt.placeholder)) {\n        const node = this.startNode();\n        this.next();\n        this.assertNoSpace();\n\n        // We can't use this.parseIdentifier because\n        // we don't want nested placeholders.\n        node.name = super.parseIdentifier(/* liberal */ true);\n\n        this.assertNoSpace();\n        this.expect(tt.placeholder);\n        // @ts-expect-error placeholder typings\n        return this.finishPlaceholder(node, expectedNode);\n      }\n    }\n\n    finishPlaceholder<T extends PlaceholderTypes>(\n      node: N.Node,\n      expectedNode: T,\n    ): /*N.Placeholder<T>*/ MaybePlaceholder<T> {\n      const isFinished = !!(node.expectedNode && node.type === \"Placeholder\");\n      node.expectedNode = expectedNode;\n\n      // @ts-expect-error todo(flow->ts)\n      return isFinished ? node : this.finishNode(node, \"Placeholder\");\n    }\n\n    /* ============================================================ *\n     * tokenizer/index.js                                           *\n     * ============================================================ */\n\n    getTokenFromCode(code: number) {\n      if (\n        code === charCodes.percentSign &&\n        this.input.charCodeAt(this.state.pos + 1) === charCodes.percentSign\n      ) {\n        this.finishOp(tt.placeholder, 2);\n      } else {\n        super.getTokenFromCode(code);\n      }\n    }\n\n    /* ============================================================ *\n     * parser/expression.js                                         *\n     * ============================================================ */\n\n    parseExprAtom(\n      refExpressionErrors?: ExpressionErrors | null,\n    ): MaybePlaceholder<\"Expression\"> {\n      return (\n        this.parsePlaceholder(\"Expression\") ||\n        super.parseExprAtom(refExpressionErrors)\n      );\n    }\n\n    parseIdentifier(liberal?: boolean): MaybePlaceholder<\"Identifier\"> {\n      // NOTE: This function only handles identifiers outside of\n      // expressions and binding patterns, since they are already\n      // handled by the parseExprAtom and parseBindingAtom functions.\n      // This is needed, for example, to parse \"class %%NAME%% {}\".\n      return (\n        this.parsePlaceholder(\"Identifier\") || super.parseIdentifier(liberal)\n      );\n    }\n\n    checkReservedWord(\n      word: string,\n      startLoc: Position,\n      checkKeywords: boolean,\n      isBinding: boolean,\n    ) {\n      // Sometimes we call #checkReservedWord(node.name), expecting\n      // that node is an Identifier. If it is a Placeholder, name\n      // will be undefined.\n      if (word !== undefined) {\n        super.checkReservedWord(word, startLoc, checkKeywords, isBinding);\n      }\n    }\n\n    /* ============================================================ *\n     * parser/lval.js                                               *\n     * ============================================================ */\n\n    parseBindingAtom(): MaybePlaceholder<\"Pattern\"> {\n      return this.parsePlaceholder(\"Pattern\") || super.parseBindingAtom();\n    }\n\n    isValidLVal(type: string, isParenthesized: boolean, binding: BindingTypes) {\n      return (\n        type === \"Placeholder\" ||\n        super.isValidLVal(type, isParenthesized, binding)\n      );\n    }\n\n    toAssignable(node: N.Node, isLHS: boolean): void {\n      if (\n        node &&\n        node.type === \"Placeholder\" &&\n        node.expectedNode === \"Expression\"\n      ) {\n        node.expectedNode = \"Pattern\";\n      } else {\n        super.toAssignable(node, isLHS);\n      }\n    }\n\n    /* ============================================================ *\n     * parser/statement.js                                          *\n     * ============================================================ */\n\n    chStartsBindingIdentifier(ch: number, pos: number): boolean {\n      if (super.chStartsBindingIdentifier(ch, pos)) {\n        return true;\n      }\n\n      // Accept \"let %%\" as the start of \"let %%placeholder%%\", as though the\n      // placeholder were an identifier.\n      const nextToken = this.lookahead();\n      if (nextToken.type === tt.placeholder) {\n        return true;\n      }\n\n      return false;\n    }\n\n    verifyBreakContinue(\n      node: N.BreakStatement | N.ContinueStatement,\n      isBreak: boolean,\n    ) {\n      // @ts-expect-error: node.label could be Placeholder\n      if (node.label && node.label.type === \"Placeholder\") return;\n      super.verifyBreakContinue(node, isBreak);\n    }\n\n    // @ts-expect-error Plugin will override parser interface\n    parseExpressionStatement(\n      node: MaybePlaceholder<\"Statement\">,\n      expr: N.Expression,\n    ): MaybePlaceholder<\"Statement\"> {\n      if (\n        expr.type !== \"Placeholder\" ||\n        (expr.extra && expr.extra.parenthesized)\n      ) {\n        // @ts-expect-error placeholder typings\n        return super.parseExpressionStatement(node, expr);\n      }\n\n      if (this.match(tt.colon)) {\n        // @ts-expect-error placeholder typings\n        const stmt: N.LabeledStatement = node;\n        stmt.label = this.finishPlaceholder(expr, \"Identifier\");\n        this.next();\n        stmt.body = super.parseStatementOrSloppyAnnexBFunctionDeclaration();\n        return this.finishNode(stmt, \"LabeledStatement\");\n      }\n\n      this.semicolon();\n      node.name = expr.name;\n      return this.finishPlaceholder(node, \"Statement\");\n    }\n\n    parseBlock(\n      allowDirectives?: boolean,\n      createNewLexicalScope?: boolean,\n      afterBlockParse?: (hasStrictModeDirective: boolean) => void,\n    ): MaybePlaceholder<\"BlockStatement\"> {\n      return (\n        this.parsePlaceholder(\"BlockStatement\") ||\n        super.parseBlock(\n          allowDirectives,\n          createNewLexicalScope,\n          afterBlockParse,\n        )\n      );\n    }\n\n    parseFunctionId(\n      requireId?: boolean,\n    ): MaybePlaceholder<\"Identifier\"> | undefined | null {\n      return (\n        this.parsePlaceholder(\"Identifier\") || super.parseFunctionId(requireId)\n      );\n    }\n    // @ts-expect-error Plugin will override parser interface\n    parseClass<T extends N.Class>(\n      node: T,\n      isStatement: /* T === ClassDeclaration */ boolean,\n      optionalId?: boolean,\n    ): T {\n      const type = isStatement ? \"ClassDeclaration\" : \"ClassExpression\";\n\n      this.next();\n      const oldStrict = this.state.strict;\n\n      const placeholder = this.parsePlaceholder(\"Identifier\");\n      if (placeholder) {\n        if (\n          this.match(tt._extends) ||\n          this.match(tt.placeholder) ||\n          this.match(tt.braceL)\n        ) {\n          node.id = placeholder;\n        } else if (optionalId || !isStatement) {\n          node.id = null;\n          node.body = this.finishPlaceholder(placeholder, \"ClassBody\");\n          return this.finishNode(node, type);\n        } else {\n          throw this.raise(PlaceholderErrors.ClassNameIsRequired, {\n            at: this.state.startLoc,\n          });\n        }\n      } else {\n        this.parseClassId(node, isStatement, optionalId);\n      }\n\n      super.parseClassSuper(node);\n      node.body =\n        this.parsePlaceholder(\"ClassBody\") ||\n        super.parseClassBody(!!node.superClass, oldStrict);\n      return this.finishNode(node, type);\n    }\n\n    parseExport(node: N.Node, decorators: N.Decorator[] | null): N.AnyExport {\n      const placeholder = this.parsePlaceholder(\"Identifier\");\n      if (!placeholder) return super.parseExport(node, decorators);\n\n      if (!this.isContextual(tt._from) && !this.match(tt.comma)) {\n        // export %%DECL%%;\n        node.specifiers = [];\n        node.source = null;\n        node.declaration = this.finishPlaceholder(placeholder, \"Declaration\");\n        return this.finishNode(node, \"ExportNamedDeclaration\");\n      }\n\n      // export %%NAME%% from \"foo\";\n      this.expectPlugin(\"exportDefaultFrom\");\n      const specifier = this.startNode();\n      specifier.exported = placeholder;\n      node.specifiers = [this.finishNode(specifier, \"ExportDefaultSpecifier\")];\n\n      return super.parseExport(node, decorators);\n    }\n\n    isExportDefaultSpecifier(): boolean {\n      if (this.match(tt._default)) {\n        const next = this.nextTokenStart();\n        if (this.isUnparsedContextual(next, \"from\")) {\n          if (\n            this.input.startsWith(\n              tokenLabelName(tt.placeholder),\n              this.nextTokenStartSince(next + 4),\n            )\n          ) {\n            return true;\n          }\n        }\n      }\n      return super.isExportDefaultSpecifier();\n    }\n\n    maybeParseExportDefaultSpecifier(\n      node: Undone<\n        | N.ExportDefaultDeclaration\n        | N.ExportAllDeclaration\n        | N.ExportNamedDeclaration\n      >,\n      maybeDefaultIdentifier: N.Identifier | null,\n    ): node is Undone<N.ExportNamedDeclaration> {\n      if ((node as N.ExportNamedDeclaration).specifiers?.length) {\n        // \"export %%NAME%%\" has already been parsed by #parseExport.\n        return true;\n      }\n      return super.maybeParseExportDefaultSpecifier(\n        node,\n        maybeDefaultIdentifier,\n      );\n    }\n\n    checkExport(node: N.ExportNamedDeclaration): void {\n      const { specifiers } = node;\n      if (specifiers?.length) {\n        node.specifiers = specifiers.filter(\n          // @ts-expect-error placeholder typings\n          node => node.exported.type === \"Placeholder\",\n        );\n      }\n      super.checkExport(node);\n      node.specifiers = specifiers;\n    }\n\n    parseImport(\n      node: Undone<N.ImportDeclaration>,\n    ): N.ImportDeclaration | N.TsImportEqualsDeclaration {\n      const placeholder = this.parsePlaceholder(\"Identifier\");\n      if (!placeholder) return super.parseImport(node);\n\n      node.specifiers = [];\n\n      if (!this.isContextual(tt._from) && !this.match(tt.comma)) {\n        // import %%STRING%%;\n        node.source = this.finishPlaceholder(placeholder, \"StringLiteral\");\n        this.semicolon();\n        return this.finishNode(node, \"ImportDeclaration\");\n      }\n\n      // import %%DEFAULT%% ...\n      const specifier =\n        this.startNodeAtNode<N.ImportDefaultSpecifier>(placeholder);\n      specifier.local = placeholder;\n      node.specifiers.push(\n        this.finishNode(specifier, \"ImportDefaultSpecifier\"),\n      );\n\n      if (this.eat(tt.comma)) {\n        // import %%DEFAULT%%, * as ...\n        const hasStarImport = this.maybeParseStarImportSpecifier(node);\n\n        // import %%DEFAULT%%, { ...\n        if (!hasStarImport) this.parseNamedImportSpecifiers(node);\n      }\n\n      this.expectContextual(tt._from);\n      node.source = this.parseImportSource();\n      this.semicolon();\n      return this.finishNode(node, \"ImportDeclaration\");\n    }\n\n    parseImportSource(): MaybePlaceholder<\"StringLiteral\"> {\n      // import ... from %%STRING%%;\n\n      return (\n        this.parsePlaceholder(\"StringLiteral\") || super.parseImportSource()\n      );\n    }\n\n    // Throws if the current token and the prev one are separated by a space.\n    assertNoSpace(): void {\n      if (this.state.start > this.state.lastTokEndLoc.index) {\n        this.raise(PlaceholderErrors.UnexpectedSpace, {\n          at: this.state.lastTokEndLoc,\n        });\n      }\n    }\n  };\n","import type Parser from \"../parser\";\nimport { tokenIsIdentifier, tt } from \"../tokenizer/types\";\nimport type * as N from \"../types\";\nimport type { ExpressionErrors } from \"../parser/util\";\n\nexport default (superClass: typeof Parser) =>\n  class V8IntrinsicMixin extends superClass implements Parser {\n    parseV8Intrinsic(): N.Expression {\n      if (this.match(tt.modulo)) {\n        const v8IntrinsicStartLoc = this.state.startLoc;\n        // let the `loc` of Identifier starts from `%`\n        const node = this.startNode<N.Identifier>();\n        this.next(); // eat '%'\n        if (tokenIsIdentifier(this.state.type)) {\n          const name = this.parseIdentifierName();\n          const identifier = this.createIdentifier(node, name);\n          // @ts-expect-error: avoid mutating AST types\n          identifier.type = \"V8IntrinsicIdentifier\";\n          if (this.match(tt.parenL)) {\n            return identifier;\n          }\n        }\n        this.unexpected(v8IntrinsicStartLoc);\n      }\n    }\n\n    /* ============================================================ *\n     * parser/expression.js                                         *\n     * ============================================================ */\n\n    parseExprAtom(refExpressionErrors?: ExpressionErrors | null): N.Expression {\n      return (\n        this.parseV8Intrinsic() || super.parseExprAtom(refExpressionErrors)\n      );\n    }\n  };\n","import type Parser from \"./parser\";\nimport type {\n  ParserPluginWithOptions,\n  PluginConfig,\n  PluginOptions,\n} from \"./typings\";\n\nexport type Plugin = PluginConfig;\n\nexport type PluginList = PluginConfig[];\n\nexport type MixinPlugin = (superClass: { new (...args: any): Parser }) => {\n  new (...args: any): Parser;\n};\n\n// This function’s second parameter accepts either a string (plugin name) or an\n// array pair (plugin name and options object). If an options object is given,\n// then each value is non-recursively checked for identity with the actual\n// option value of each plugin in the first argument (which is an array of\n// plugin names or array pairs).\nexport function hasPlugin(\n  plugins: PluginList,\n  expectedConfig: PluginConfig,\n): boolean {\n  // The expectedOptions object is by default an empty object if the given\n  // expectedConfig argument does not give an options object (i.e., if it is a\n  // string).\n  const [expectedName, expectedOptions] =\n    typeof expectedConfig === \"string\" ? [expectedConfig, {}] : expectedConfig;\n\n  const expectedKeys = Object.keys(expectedOptions);\n\n  const expectedOptionsIsEmpty = expectedKeys.length === 0;\n\n  return plugins.some(p => {\n    if (typeof p === \"string\") {\n      return expectedOptionsIsEmpty && p === expectedName;\n    } else {\n      const [pluginName, pluginOptions] = p;\n      if (pluginName !== expectedName) {\n        return false;\n      }\n      for (const key of expectedKeys) {\n        // @ts-expect-error key may not exist in plugin options\n        if (pluginOptions[key] !== expectedOptions[key]) {\n          return false;\n        }\n      }\n      return true;\n    }\n  });\n}\n\nexport function getPluginOption<\n  PluginName extends ParserPluginWithOptions[0],\n  OptionName extends keyof PluginOptions<PluginName>,\n>(plugins: PluginList, name: PluginName, option: OptionName) {\n  const plugin = plugins.find(plugin => {\n    if (Array.isArray(plugin)) {\n      return plugin[0] === name;\n    } else {\n      return plugin === name;\n    }\n  });\n\n  if (plugin && Array.isArray(plugin) && plugin.length > 1) {\n    return (plugin[1] as PluginOptions<PluginName>)[option];\n  }\n\n  return null;\n}\n\nconst PIPELINE_PROPOSALS = [\"minimal\", \"fsharp\", \"hack\", \"smart\"];\nconst TOPIC_TOKENS = [\"^^\", \"@@\", \"^\", \"%\", \"#\"];\nconst RECORD_AND_TUPLE_SYNTAX_TYPES = [\"hash\", \"bar\"];\n\nexport function validatePlugins(plugins: PluginList) {\n  if (hasPlugin(plugins, \"decorators\")) {\n    if (hasPlugin(plugins, \"decorators-legacy\")) {\n      throw new Error(\n        \"Cannot use the decorators and decorators-legacy plugin together\",\n      );\n    }\n\n    const decoratorsBeforeExport = getPluginOption(\n      plugins,\n      \"decorators\",\n      \"decoratorsBeforeExport\",\n    );\n    if (\n      decoratorsBeforeExport != null &&\n      typeof decoratorsBeforeExport !== \"boolean\"\n    ) {\n      throw new Error(\n        \"'decoratorsBeforeExport' must be a boolean, if specified.\",\n      );\n    }\n\n    const allowCallParenthesized = getPluginOption(\n      plugins,\n      \"decorators\",\n      \"allowCallParenthesized\",\n    );\n    if (\n      allowCallParenthesized != null &&\n      typeof allowCallParenthesized !== \"boolean\"\n    ) {\n      throw new Error(\"'allowCallParenthesized' must be a boolean.\");\n    }\n  }\n\n  if (hasPlugin(plugins, \"flow\") && hasPlugin(plugins, \"typescript\")) {\n    throw new Error(\"Cannot combine flow and typescript plugins.\");\n  }\n\n  if (hasPlugin(plugins, \"placeholders\") && hasPlugin(plugins, \"v8intrinsic\")) {\n    throw new Error(\"Cannot combine placeholders and v8intrinsic plugins.\");\n  }\n\n  if (hasPlugin(plugins, \"pipelineOperator\")) {\n    const proposal = getPluginOption(plugins, \"pipelineOperator\", \"proposal\");\n\n    if (!PIPELINE_PROPOSALS.includes(proposal)) {\n      const proposalList = PIPELINE_PROPOSALS.map(p => `\"${p}\"`).join(\", \");\n      throw new Error(\n        `\"pipelineOperator\" requires \"proposal\" option whose value must be one of: ${proposalList}.`,\n      );\n    }\n\n    const tupleSyntaxIsHash = hasPlugin(plugins, [\n      \"recordAndTuple\",\n      { syntaxType: \"hash\" },\n    ]);\n\n    if (proposal === \"hack\") {\n      if (hasPlugin(plugins, \"placeholders\")) {\n        throw new Error(\n          \"Cannot combine placeholders plugin and Hack-style pipes.\",\n        );\n      }\n\n      if (hasPlugin(plugins, \"v8intrinsic\")) {\n        throw new Error(\n          \"Cannot combine v8intrinsic plugin and Hack-style pipes.\",\n        );\n      }\n\n      const topicToken = getPluginOption(\n        plugins,\n        \"pipelineOperator\",\n        \"topicToken\",\n      );\n\n      if (!TOPIC_TOKENS.includes(topicToken)) {\n        const tokenList = TOPIC_TOKENS.map(t => `\"${t}\"`).join(\", \");\n\n        throw new Error(\n          `\"pipelineOperator\" in \"proposal\": \"hack\" mode also requires a \"topicToken\" option whose value must be one of: ${tokenList}.`,\n        );\n      }\n\n      if (topicToken === \"#\" && tupleSyntaxIsHash) {\n        throw new Error(\n          'Plugin conflict between `[\"pipelineOperator\", { proposal: \"hack\", topicToken: \"#\" }]` and `[\"recordAndtuple\", { syntaxType: \"hash\"}]`.',\n        );\n      }\n    } else if (proposal === \"smart\" && tupleSyntaxIsHash) {\n      throw new Error(\n        'Plugin conflict between `[\"pipelineOperator\", { proposal: \"smart\" }]` and `[\"recordAndtuple\", { syntaxType: \"hash\"}]`.',\n      );\n    }\n  }\n\n  if (hasPlugin(plugins, \"moduleAttributes\")) {\n    if (process.env.BABEL_8_BREAKING) {\n      throw new Error(\n        \"`moduleAttributes` has been removed in Babel 8, please use `importAttributes` parser plugin, or `@babel/plugin-syntax-import-attributes`.\",\n      );\n    } else {\n      if (\n        hasPlugin(plugins, \"importAssertions\") ||\n        hasPlugin(plugins, \"importAttributes\")\n      ) {\n        throw new Error(\n          \"Cannot combine importAssertions, importAttributes and moduleAttributes plugins.\",\n        );\n      }\n      const moduleAttributesVersionPluginOption = getPluginOption(\n        plugins,\n        \"moduleAttributes\",\n        \"version\",\n      );\n      if (moduleAttributesVersionPluginOption !== \"may-2020\") {\n        throw new Error(\n          \"The 'moduleAttributes' plugin requires a 'version' option,\" +\n            \" representing the last proposal update. Currently, the\" +\n            \" only supported value is 'may-2020'.\",\n        );\n      }\n    }\n  }\n  if (\n    hasPlugin(plugins, \"importAssertions\") &&\n    hasPlugin(plugins, \"importAttributes\")\n  ) {\n    throw new Error(\n      \"Cannot combine importAssertions and importAttributes plugins.\",\n    );\n  }\n\n  if (\n    hasPlugin(plugins, \"recordAndTuple\") &&\n    getPluginOption(plugins, \"recordAndTuple\", \"syntaxType\") != null &&\n    !RECORD_AND_TUPLE_SYNTAX_TYPES.includes(\n      getPluginOption(plugins, \"recordAndTuple\", \"syntaxType\"),\n    )\n  ) {\n    throw new Error(\n      \"The 'syntaxType' option of the 'recordAndTuple' plugin must be one of: \" +\n        RECORD_AND_TUPLE_SYNTAX_TYPES.map(p => `'${p}'`).join(\", \"),\n    );\n  }\n\n  if (\n    hasPlugin(plugins, \"asyncDoExpressions\") &&\n    !hasPlugin(plugins, \"doExpressions\")\n  ) {\n    const error = new Error(\n      \"'asyncDoExpressions' requires 'doExpressions', please add 'doExpressions' to parser plugins.\",\n    );\n    // @ts-expect-error so @babel/core can provide better error message\n    error.missingPlugins = \"doExpressions\";\n    throw error;\n  }\n}\n\n// These plugins are defined using a mixin which extends the parser class.\n\nimport estree from \"./plugins/estree\";\nimport flow from \"./plugins/flow\";\nimport jsx from \"./plugins/jsx\";\nimport typescript from \"./plugins/typescript\";\nimport placeholders from \"./plugins/placeholders\";\nimport v8intrinsic from \"./plugins/v8intrinsic\";\n\n// NOTE: order is important. estree must come first; placeholders must come last.\nexport const mixinPlugins = {\n  estree,\n  jsx,\n  flow,\n  typescript,\n  v8intrinsic,\n  placeholders,\n};\n\nexport const mixinPluginNames = Object.keys(mixinPlugins) as ReadonlyArray<\n  \"estree\" | \"jsx\" | \"flow\" | \"typescript\" | \"v8intrinsic\" | \"placeholders\"\n>;\n","import type { PluginList } from \"./plugin-utils\";\n\n// A second optional argument can be given to further configure\n// the parser process. These options are recognized:\n\nexport type SourceType = \"script\" | \"module\" | \"unambiguous\";\n\nexport type Options = {\n  sourceType: SourceType;\n  sourceFilename?: string;\n  startColumn: number;\n  startLine: number;\n  allowAwaitOutsideFunction: boolean;\n  allowReturnOutsideFunction: boolean;\n  allowNewTargetOutsideFunction: boolean;\n  allowImportExportEverywhere: boolean;\n  allowSuperOutsideMethod: boolean;\n  allowUndeclaredExports: boolean;\n  plugins: PluginList;\n  strictMode: boolean | undefined | null;\n  ranges: boolean;\n  tokens: boolean;\n  createParenthesizedExpressions: boolean;\n  errorRecovery: boolean;\n  attachComment: boolean;\n  annexB: boolean;\n};\n\nexport const defaultOptions: Options = {\n  // Source type (\"script\" or \"module\") for different semantics\n  sourceType: \"script\",\n  // Source filename.\n  sourceFilename: undefined,\n  // Column (0-based) from which to start counting source. Useful for\n  // integration with other tools.\n  startColumn: 0,\n  // Line (1-based) from which to start counting source. Useful for\n  // integration with other tools.\n  startLine: 1,\n  // When enabled, await at the top level is not considered an\n  // error.\n  allowAwaitOutsideFunction: false,\n  // When enabled, a return at the top level is not considered an\n  // error.\n  allowReturnOutsideFunction: false,\n  // When enabled, new.target outside a function or class is not\n  // considered an error.\n  allowNewTargetOutsideFunction: false,\n  // When enabled, import/export statements are not constrained to\n  // appearing at the top of the program.\n  allowImportExportEverywhere: false,\n  // TODO\n  allowSuperOutsideMethod: false,\n  // When enabled, export statements can reference undeclared variables.\n  allowUndeclaredExports: false,\n  // An array of plugins to enable\n  plugins: [],\n  // TODO\n  strictMode: null,\n  // Nodes have their start and end characters offsets recorded in\n  // `start` and `end` properties (directly on the node, rather than\n  // the `loc` object, which holds line/column data. To also add a\n  // [semi-standardized][range] `range` property holding a `[start,\n  // end]` array with the same numbers, set the `ranges` option to\n  // `true`.\n  //\n  // [range]: https://bugzilla.mozilla.org/show_bug.cgi?id=745678\n  ranges: false,\n  // Adds all parsed tokens to a `tokens` property on the `File` node\n  tokens: false,\n  // Whether to create ParenthesizedExpression AST nodes (if false\n  // the parser sets extra.parenthesized on the expression nodes instead).\n  createParenthesizedExpressions: false,\n  // When enabled, errors are attached to the AST instead of being directly thrown.\n  // Some errors will still throw, because @babel/parser can't always recover.\n  errorRecovery: false,\n  // When enabled, comments will be attached to adjacent AST nodes as one of\n  // `leadingComments`, `trailingComments` and `innerComments`. The comment attachment\n  // is vital to preserve comments after transform. If you don't print AST back,\n  // consider set this option to `false` for performance\n  attachComment: true,\n  // When enabled, the parser will support Annex B syntax.\n  // https://tc39.es/ecma262/#sec-additional-ecmascript-features-for-web-browsers\n  annexB: true,\n};\n\n// Interpret and default an options object\n\nexport function getOptions(opts?: Options | null): Options {\n  if (opts && opts.annexB != null && opts.annexB !== false) {\n    throw new Error(\"The `annexB` option can only be set to `false`.\");\n  }\n\n  const options: any = {};\n  for (const key of Object.keys(defaultOptions)) {\n    // @ts-expect-error key may not exist in opts\n    options[key] = opts && opts[key] != null ? opts[key] : defaultOptions[key];\n  }\n  return options;\n}\n","// A recursive descent parser operates by defining functions for all\n// syntactic elements, and recursively calling those, each function\n// advancing the input stream and returning an AST node. Precedence\n// of constructs (for example, the fact that `!x[1]` means `!(x[1])`\n// instead of `(!x)[1]` is handled by the fact that the parser\n// function that parses unary prefix operators is called first, and\n// in turn calls the function that parses `[]` subscripts — that\n// way, it'll receive the node for `x[1]` already parsed, and wraps\n// *that* in the unary operator node.\n//\n// Acorn uses an [operator precedence parser][opp] to handle binary\n// operator precedence, because it is much more compact than using\n// the technique outlined above, which uses different, nesting\n// functions to specify precedence, for all of the ten binary\n// precedence levels that JavaScript defines.\n//\n// [opp]: http://en.wikipedia.org/wiki/Operator-precedence_parser\n\nimport {\n  tokenCanStartExpression,\n  tokenIsAssignment,\n  tokenIsIdentifier,\n  tokenIsKeywordOrIdentifier,\n  tokenIsOperator,\n  tokenIsPostfix,\n  tokenIsPrefix,\n  tokenIsRightAssociative,\n  tokenIsTemplate,\n  tokenKeywordOrIdentifierIsKeyword,\n  tokenLabelName,\n  tokenOperatorPrecedence,\n  tt,\n  type TokenType,\n} from \"../tokenizer/types\";\nimport type * as N from \"../types\";\nimport LValParser from \"./lval\";\nimport {\n  isKeyword,\n  isReservedWord,\n  isStrictReservedWord,\n  isStrictBindReservedWord,\n  isIdentifierStart,\n  canBeReservedWord,\n} from \"../util/identifier\";\nimport {\n  type Position,\n  createPositionWithColumnOffset,\n} from \"../util/location\";\nimport * as charCodes from \"charcodes\";\nimport {\n  BIND_OUTSIDE,\n  BIND_VAR,\n  SCOPE_ARROW,\n  SCOPE_CLASS,\n  SCOPE_DIRECT_SUPER,\n  SCOPE_FUNCTION,\n  SCOPE_SUPER,\n} from \"../util/scopeflags\";\nimport { ExpressionErrors } from \"./util\";\nimport {\n  PARAM_AWAIT,\n  PARAM_IN,\n  PARAM_RETURN,\n  functionFlags,\n} from \"../util/production-parameter\";\nimport {\n  newArrowHeadScope,\n  newAsyncArrowScope,\n  newExpressionScope,\n} from \"../util/expression-scope\";\nimport { Errors, type ParseError } from \"../parse-error\";\nimport { UnparenthesizedPipeBodyDescriptions } from \"../parse-error/pipeline-operator-errors\";\nimport { setInnerComments } from \"./comments\";\nimport { cloneIdentifier, type Undone } from \"./node\";\nimport type Parser from \".\";\n\nimport type { SourceType } from \"../options\";\n\nexport default abstract class ExpressionParser extends LValParser {\n  // Forward-declaration: defined in statement.js\n  abstract parseBlock(\n    allowDirectives?: boolean,\n    createNewLexicalScope?: boolean,\n    afterBlockParse?: (hasStrictModeDirective: boolean) => void,\n  ): N.BlockStatement;\n  abstract parseClass(\n    node: N.Class,\n    isStatement: boolean,\n    optionalId?: boolean,\n  ): N.Class;\n  abstract parseDecorators(allowExport?: boolean): void;\n  abstract parseFunction<T extends N.NormalFunction>(\n    node: T,\n    statement?: number,\n    allowExpressionBody?: boolean,\n    isAsync?: boolean,\n  ): T;\n  abstract parseFunctionParams(node: N.Function, isConstructor?: boolean): void;\n  abstract parseBlockOrModuleBlockBody(\n    body: N.Statement[],\n    directives: N.Directive[] | null | undefined,\n    topLevel: boolean,\n    end: TokenType,\n    afterBlockParse?: (hasStrictModeDirective: boolean) => void,\n  ): void;\n  abstract parseProgram(\n    program: N.Program,\n    end: TokenType,\n    sourceType?: SourceType,\n  ): N.Program;\n\n  // For object literal, check if property __proto__ has been used more than once.\n  // If the expression is a destructuring assignment, then __proto__ may appear\n  // multiple times. Otherwise, __proto__ is a duplicated key.\n\n  // For record expression, check if property __proto__ exists\n\n  checkProto(\n    prop: N.ObjectMember | N.SpreadElement,\n    isRecord: boolean | undefined | null,\n    protoRef: {\n      used: boolean;\n    },\n    refExpressionErrors?: ExpressionErrors | null,\n  ): void {\n    if (\n      prop.type === \"SpreadElement\" ||\n      this.isObjectMethod(prop) ||\n      prop.computed ||\n      // @ts-expect-error prop must be an ObjectProperty\n      prop.shorthand\n    ) {\n      return;\n    }\n\n    const key = prop.key;\n    // It is either an Identifier or a String/NumericLiteral\n    const name = key.type === \"Identifier\" ? key.name : key.value;\n\n    if (name === \"__proto__\") {\n      if (isRecord) {\n        this.raise(Errors.RecordNoProto, { at: key });\n        return;\n      }\n      if (protoRef.used) {\n        if (refExpressionErrors) {\n          // Store the first redefinition's position, otherwise ignore because\n          // we are parsing ambiguous pattern\n          if (refExpressionErrors.doubleProtoLoc === null) {\n            refExpressionErrors.doubleProtoLoc = key.loc.start;\n          }\n        } else {\n          this.raise(Errors.DuplicateProto, { at: key });\n        }\n      }\n\n      protoRef.used = true;\n    }\n  }\n\n  shouldExitDescending(expr: N.Expression, potentialArrowAt: number): boolean {\n    return (\n      expr.type === \"ArrowFunctionExpression\" && expr.start === potentialArrowAt\n    );\n  }\n\n  // Convenience method to parse an Expression only\n  getExpression(this: Parser): N.Expression & N.ParserOutput {\n    this.enterInitialScopes();\n    this.nextToken();\n    const expr = this.parseExpression();\n    if (!this.match(tt.eof)) {\n      this.unexpected();\n    }\n    // Unlike parseTopLevel, we need to drain remaining commentStacks\n    // because the top level node is _not_ Program.\n    this.finalizeRemainingComments();\n    expr.comments = this.state.comments;\n    expr.errors = this.state.errors;\n    if (this.options.tokens) {\n      expr.tokens = this.tokens;\n    }\n    // @ts-expect-error fixme: refine types\n    return expr;\n  }\n\n  // ### Expression parsing\n\n  // These nest, from the most general expression type at the top to\n  // 'atomic', nondivisible expression types at the bottom. Most of\n  // the functions will simply let the function (s) below them parse,\n  // and, *if* the syntactic construct they handle is present, wrap\n  // the AST node that the inner parser gave them in another node.\n\n  // Parse a full expression.\n  // - `disallowIn`\n  //   is used to forbid the `in` operator (in for loops initialization expressions)\n  //   When `disallowIn` is true, the production parameter [In] is not present.\n\n  // - `refExpressionErrors `\n  //   provides reference for storing '=' operator inside shorthand\n  //   property assignment in contexts where both object expression\n  //   and object pattern might appear (so it's possible to raise\n  //   delayed syntax error at correct position).\n\n  parseExpression(\n    this: Parser,\n    disallowIn?: boolean,\n    refExpressionErrors?: ExpressionErrors,\n  ): N.Expression {\n    if (disallowIn) {\n      return this.disallowInAnd(() =>\n        this.parseExpressionBase(refExpressionErrors),\n      );\n    }\n    return this.allowInAnd(() => this.parseExpressionBase(refExpressionErrors));\n  }\n\n  // https://tc39.es/ecma262/#prod-Expression\n  parseExpressionBase(\n    this: Parser,\n    refExpressionErrors?: ExpressionErrors,\n  ): N.Expression {\n    const startLoc = this.state.startLoc;\n    const expr = this.parseMaybeAssign(refExpressionErrors);\n    if (this.match(tt.comma)) {\n      const node = this.startNodeAt(startLoc);\n      node.expressions = [expr];\n      while (this.eat(tt.comma)) {\n        node.expressions.push(this.parseMaybeAssign(refExpressionErrors));\n      }\n      this.toReferencedList(node.expressions);\n      return this.finishNode(node, \"SequenceExpression\");\n    }\n    return expr;\n  }\n\n  // Set [~In] parameter for assignment expression\n  parseMaybeAssignDisallowIn(\n    this: Parser,\n    refExpressionErrors?: ExpressionErrors | null,\n    afterLeftParse?: Function,\n  ) {\n    return this.disallowInAnd(() =>\n      this.parseMaybeAssign(refExpressionErrors, afterLeftParse),\n    );\n  }\n\n  // Set [+In] parameter for assignment expression\n  parseMaybeAssignAllowIn(\n    this: Parser,\n    refExpressionErrors?: ExpressionErrors | null,\n    afterLeftParse?: Function,\n  ) {\n    return this.allowInAnd(() =>\n      this.parseMaybeAssign(refExpressionErrors, afterLeftParse),\n    );\n  }\n\n  // This method is only used by\n  // the typescript and flow plugins.\n  setOptionalParametersError(\n    refExpressionErrors: ExpressionErrors,\n    resultError?: ParseError<any>,\n  ) {\n    refExpressionErrors.optionalParametersLoc =\n      resultError?.loc ?? this.state.startLoc;\n  }\n\n  // Parse an assignment expression. This includes applications of\n  // operators like `+=`.\n  // https://tc39.es/ecma262/#prod-AssignmentExpression\n  parseMaybeAssign(\n    this: Parser,\n    refExpressionErrors?: ExpressionErrors | null,\n    afterLeftParse?: Function,\n  ): N.Expression {\n    const startLoc = this.state.startLoc;\n    if (this.isContextual(tt._yield)) {\n      if (this.prodParam.hasYield) {\n        let left = this.parseYield();\n        if (afterLeftParse) {\n          left = afterLeftParse.call(this, left, startLoc);\n        }\n        return left;\n      }\n    }\n\n    let ownExpressionErrors;\n    if (refExpressionErrors) {\n      ownExpressionErrors = false;\n    } else {\n      refExpressionErrors = new ExpressionErrors();\n      ownExpressionErrors = true;\n    }\n    const { type } = this.state;\n\n    if (type === tt.parenL || tokenIsIdentifier(type)) {\n      this.state.potentialArrowAt = this.state.start;\n    }\n\n    let left = this.parseMaybeConditional(refExpressionErrors);\n    if (afterLeftParse) {\n      left = afterLeftParse.call(this, left, startLoc);\n    }\n    if (tokenIsAssignment(this.state.type)) {\n      const node = this.startNodeAt<N.AssignmentExpression>(startLoc);\n      const operator = this.state.value;\n      node.operator = operator;\n\n      if (this.match(tt.eq)) {\n        this.toAssignable(left, /* isLHS */ true);\n        node.left = left;\n\n        const startIndex = startLoc.index;\n        if (\n          refExpressionErrors.doubleProtoLoc != null &&\n          refExpressionErrors.doubleProtoLoc.index >= startIndex\n        ) {\n          refExpressionErrors.doubleProtoLoc = null; // reset because double __proto__ is valid in assignment expression\n        }\n        if (\n          refExpressionErrors.shorthandAssignLoc != null &&\n          refExpressionErrors.shorthandAssignLoc.index >= startIndex\n        ) {\n          refExpressionErrors.shorthandAssignLoc = null; // reset because shorthand default was used correctly\n        }\n        if (\n          refExpressionErrors.privateKeyLoc != null &&\n          refExpressionErrors.privateKeyLoc.index >= startIndex\n        ) {\n          this.checkDestructuringPrivate(refExpressionErrors);\n          refExpressionErrors.privateKeyLoc = null; // reset because `({ #x: x })` is an assignable pattern\n        }\n      } else {\n        node.left = left;\n      }\n\n      this.next();\n      node.right = this.parseMaybeAssign();\n      this.checkLVal(left, {\n        in: this.finishNode(node, \"AssignmentExpression\"),\n      });\n      // @ts-expect-error todo(flow->ts) improve node types\n      return node;\n    } else if (ownExpressionErrors) {\n      this.checkExpressionErrors(refExpressionErrors, true);\n    }\n\n    return left;\n  }\n\n  // Parse a ternary conditional (`?:`) operator.\n  // https://tc39.es/ecma262/#prod-ConditionalExpression\n\n  parseMaybeConditional(\n    this: Parser,\n    refExpressionErrors: ExpressionErrors,\n  ): N.Expression {\n    const startLoc = this.state.startLoc;\n    const potentialArrowAt = this.state.potentialArrowAt;\n    const expr = this.parseExprOps(refExpressionErrors);\n\n    if (this.shouldExitDescending(expr, potentialArrowAt)) {\n      return expr;\n    }\n\n    return this.parseConditional(expr, startLoc, refExpressionErrors);\n  }\n\n  parseConditional(\n    this: Parser,\n    expr: N.Expression,\n    startLoc: Position,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    refExpressionErrors?: ExpressionErrors | null,\n  ): N.Expression {\n    if (this.eat(tt.question)) {\n      const node = this.startNodeAt(startLoc);\n      node.test = expr;\n      node.consequent = this.parseMaybeAssignAllowIn();\n      this.expect(tt.colon);\n      node.alternate = this.parseMaybeAssign();\n      return this.finishNode(node, \"ConditionalExpression\");\n    }\n    return expr;\n  }\n\n  parseMaybeUnaryOrPrivate(\n    this: Parser,\n    refExpressionErrors?: ExpressionErrors,\n  ): N.Expression | N.PrivateName {\n    return this.match(tt.privateName)\n      ? this.parsePrivateName()\n      : this.parseMaybeUnary(refExpressionErrors);\n  }\n\n  // Start the precedence parser.\n  // https://tc39.es/ecma262/#prod-ShortCircuitExpression\n\n  parseExprOps(\n    this: Parser,\n    refExpressionErrors: ExpressionErrors,\n  ): N.Expression {\n    const startLoc = this.state.startLoc;\n    const potentialArrowAt = this.state.potentialArrowAt;\n    const expr = this.parseMaybeUnaryOrPrivate(refExpressionErrors);\n\n    if (this.shouldExitDescending(expr, potentialArrowAt)) {\n      return expr;\n    }\n\n    return this.parseExprOp(expr, startLoc, -1);\n  }\n\n  // Parse binary operators with the operator precedence parsing\n  // algorithm. `left` is the left-hand side of the operator.\n  // `minPrec` provides context that allows the function to stop and\n  // defer further parser to one of its callers when it encounters an\n  // operator that has a lower precedence than the set it is parsing.\n\n  parseExprOp(\n    this: Parser,\n    left: N.Expression | N.PrivateName,\n    leftStartLoc: Position,\n    minPrec: number,\n  ): N.Expression {\n    if (this.isPrivateName(left)) {\n      // https://tc39.es/ecma262/#prod-RelationalExpression\n      // RelationalExpression [In, Yield, Await]\n      //   [+In] PrivateIdentifier in ShiftExpression[?Yield, ?Await]\n\n      const value = this.getPrivateNameSV(left);\n\n      if (\n        minPrec >= tokenOperatorPrecedence(tt._in) ||\n        !this.prodParam.hasIn ||\n        !this.match(tt._in)\n      ) {\n        this.raise(Errors.PrivateInExpectedIn, {\n          at: left,\n          identifierName: value,\n        });\n      }\n\n      this.classScope.usePrivateName(value, left.loc.start);\n    }\n\n    const op = this.state.type;\n    if (tokenIsOperator(op) && (this.prodParam.hasIn || !this.match(tt._in))) {\n      let prec = tokenOperatorPrecedence(op);\n      if (prec > minPrec) {\n        if (op === tt.pipeline) {\n          this.expectPlugin(\"pipelineOperator\");\n          if (this.state.inFSharpPipelineDirectBody) {\n            return left;\n          }\n          this.checkPipelineAtInfixOperator(left, leftStartLoc);\n        }\n        const node = this.startNodeAt<N.LogicalExpression | N.BinaryExpression>(\n          leftStartLoc,\n        );\n        node.left = left;\n        node.operator = this.state.value;\n\n        const logical = op === tt.logicalOR || op === tt.logicalAND;\n        const coalesce = op === tt.nullishCoalescing;\n\n        if (coalesce) {\n          // Handle the precedence of `tt.coalesce` as equal to the range of logical expressions.\n          // In other words, `node.right` shouldn't contain logical expressions in order to check the mixed error.\n          prec = tokenOperatorPrecedence(tt.logicalAND);\n        }\n\n        this.next();\n\n        if (\n          op === tt.pipeline &&\n          this.hasPlugin([\"pipelineOperator\", { proposal: \"minimal\" }])\n        ) {\n          if (this.state.type === tt._await && this.prodParam.hasAwait) {\n            throw this.raise(Errors.UnexpectedAwaitAfterPipelineBody, {\n              at: this.state.startLoc,\n            });\n          }\n        }\n\n        node.right = this.parseExprOpRightExpr(op, prec);\n        const finishedNode = this.finishNode(\n          node,\n          logical || coalesce ? \"LogicalExpression\" : \"BinaryExpression\",\n        );\n        /* this check is for all ?? operators\n         * a ?? b && c for this example\n         * when op is coalesce and nextOp is logical (&&), throw at the pos of nextOp that it can not be mixed.\n         * Symmetrically it also throws when op is logical and nextOp is coalesce\n         */\n        const nextOp = this.state.type;\n        if (\n          (coalesce && (nextOp === tt.logicalOR || nextOp === tt.logicalAND)) ||\n          (logical && nextOp === tt.nullishCoalescing)\n        ) {\n          throw this.raise(Errors.MixingCoalesceWithLogical, {\n            at: this.state.startLoc,\n          });\n        }\n\n        return this.parseExprOp(finishedNode, leftStartLoc, minPrec);\n      }\n    }\n    return left;\n  }\n\n  // Helper function for `parseExprOp`. Parse the right-hand side of binary-\n  // operator expressions, then apply any operator-specific functions.\n\n  parseExprOpRightExpr(\n    this: Parser,\n    op: TokenType,\n    prec: number,\n  ): N.Expression {\n    const startLoc = this.state.startLoc;\n    switch (op) {\n      case tt.pipeline:\n        switch (this.getPluginOption(\"pipelineOperator\", \"proposal\")) {\n          case \"hack\":\n            return this.withTopicBindingContext(() => {\n              return this.parseHackPipeBody();\n            });\n\n          case \"smart\":\n            return this.withTopicBindingContext(() => {\n              if (this.prodParam.hasYield && this.isContextual(tt._yield)) {\n                throw this.raise(Errors.PipeBodyIsTighter, {\n                  at: this.state.startLoc,\n                });\n              }\n              return this.parseSmartPipelineBodyInStyle(\n                this.parseExprOpBaseRightExpr(op, prec),\n                startLoc,\n              );\n            });\n\n          case \"fsharp\":\n            return this.withSoloAwaitPermittingContext(() => {\n              return this.parseFSharpPipelineBody(prec);\n            });\n        }\n\n      // Falls through.\n      default:\n        return this.parseExprOpBaseRightExpr(op, prec);\n    }\n  }\n\n  // Helper function for `parseExprOpRightExpr`. Parse the right-hand side of\n  // binary-operator expressions without applying any operator-specific functions.\n\n  parseExprOpBaseRightExpr(\n    this: Parser,\n    op: TokenType,\n    prec: number,\n  ): N.Expression {\n    const startLoc = this.state.startLoc;\n\n    return this.parseExprOp(\n      this.parseMaybeUnaryOrPrivate(),\n      startLoc,\n      tokenIsRightAssociative(op) ? prec - 1 : prec,\n    );\n  }\n\n  parseHackPipeBody(this: Parser): N.Expression {\n    const { startLoc } = this.state;\n    const body = this.parseMaybeAssign();\n    const requiredParentheses = UnparenthesizedPipeBodyDescriptions.has(\n      // @ts-expect-error TS2345: Argument of type 'string' is not assignable to parameter of type '\"ArrowFunctionExpression\" | \"YieldExpression\" | \"AssignmentExpression\" | \"ConditionalExpression\"'.\n      body.type,\n    );\n\n    // TODO: Check how to handle type casts in Flow and TS once they are supported\n    if (requiredParentheses && !body.extra?.parenthesized) {\n      this.raise(Errors.PipeUnparenthesizedBody, {\n        at: startLoc,\n        // @ts-expect-error TS2322: Type 'string' is not assignable to type '\"AssignmentExpression\" | \"ArrowFunctionExpression\" | \"ConditionalExpression\" | \"YieldExpression\"'.\n        type: body.type,\n      });\n    }\n    if (!this.topicReferenceWasUsedInCurrentContext()) {\n      // A Hack pipe body must use the topic reference at least once.\n      this.raise(Errors.PipeTopicUnused, { at: startLoc });\n    }\n\n    return body;\n  }\n\n  checkExponentialAfterUnary(\n    node: N.AwaitExpression | Undone<N.UnaryExpression>,\n  ) {\n    if (this.match(tt.exponent)) {\n      this.raise(Errors.UnexpectedTokenUnaryExponentiation, {\n        at: node.argument,\n      });\n    }\n  }\n\n  // Parse unary operators, both prefix and postfix.\n  // https://tc39.es/ecma262/#prod-UnaryExpression\n  parseMaybeUnary(\n    this: Parser,\n    refExpressionErrors?: ExpressionErrors | null,\n    sawUnary?: boolean,\n  ): N.Expression {\n    const startLoc = this.state.startLoc;\n    const isAwait = this.isContextual(tt._await);\n\n    if (isAwait && this.isAwaitAllowed()) {\n      this.next();\n      const expr = this.parseAwait(startLoc);\n      if (!sawUnary) this.checkExponentialAfterUnary(expr);\n      return expr;\n    }\n    const update = this.match(tt.incDec);\n    const node = this.startNode<N.UnaryExpression | N.UpdateExpression>();\n    if (tokenIsPrefix(this.state.type)) {\n      node.operator = this.state.value;\n      node.prefix = true;\n\n      if (this.match(tt._throw)) {\n        this.expectPlugin(\"throwExpressions\");\n      }\n      const isDelete = this.match(tt._delete);\n      this.next();\n\n      node.argument = this.parseMaybeUnary(null, true);\n\n      this.checkExpressionErrors(refExpressionErrors, true);\n\n      if (this.state.strict && isDelete) {\n        const arg = node.argument;\n\n        if (arg.type === \"Identifier\") {\n          this.raise(Errors.StrictDelete, { at: node });\n        } else if (this.hasPropertyAsPrivateName(arg)) {\n          this.raise(Errors.DeletePrivateField, { at: node });\n        }\n      }\n\n      if (!update) {\n        if (!sawUnary) {\n          this.checkExponentialAfterUnary(node as Undone<N.UnaryExpression>);\n        }\n        return this.finishNode(node, \"UnaryExpression\");\n      }\n    }\n\n    const expr = this.parseUpdate(\n      // @ts-expect-error using \"Undone\" node as \"done\"\n      node,\n      update,\n      refExpressionErrors,\n    );\n\n    if (isAwait) {\n      const { type } = this.state;\n      const startsExpr = this.hasPlugin(\"v8intrinsic\")\n        ? tokenCanStartExpression(type)\n        : tokenCanStartExpression(type) && !this.match(tt.modulo);\n      if (startsExpr && !this.isAmbiguousAwait()) {\n        this.raiseOverwrite(Errors.AwaitNotInAsyncContext, { at: startLoc });\n        return this.parseAwait(startLoc);\n      }\n    }\n\n    return expr;\n  }\n\n  // https://tc39.es/ecma262/#prod-UpdateExpression\n  parseUpdate(\n    this: Parser,\n    node: N.Expression,\n    update: boolean,\n    refExpressionErrors?: ExpressionErrors | null,\n  ): N.Expression {\n    if (update) {\n      // @ts-expect-error Type 'Node' is missing the following properties from type 'Undone<UpdateExpression>': prefix, operator, argument\n      const updateExpressionNode = node as Undone<N.UpdateExpression>;\n      this.checkLVal(updateExpressionNode.argument, {\n        in: this.finishNode(updateExpressionNode, \"UpdateExpression\"),\n      });\n      return node;\n    }\n\n    const startLoc = this.state.startLoc;\n    let expr = this.parseExprSubscripts(refExpressionErrors);\n    if (this.checkExpressionErrors(refExpressionErrors, false)) return expr;\n    while (tokenIsPostfix(this.state.type) && !this.canInsertSemicolon()) {\n      const node = this.startNodeAt<N.UpdateExpression>(startLoc);\n      node.operator = this.state.value;\n      node.prefix = false;\n      node.argument = expr;\n      this.next();\n      this.checkLVal(expr, {\n        in: (expr = this.finishNode(node, \"UpdateExpression\")),\n      });\n    }\n    return expr;\n  }\n\n  // Parse call, dot, and `[]`-subscript expressions.\n  // https://tc39.es/ecma262/#prod-LeftHandSideExpression\n  parseExprSubscripts(\n    this: Parser,\n    refExpressionErrors?: ExpressionErrors | null,\n  ): N.Expression {\n    const startLoc = this.state.startLoc;\n    const potentialArrowAt = this.state.potentialArrowAt;\n    const expr = this.parseExprAtom(refExpressionErrors);\n\n    if (this.shouldExitDescending(expr, potentialArrowAt)) {\n      return expr;\n    }\n\n    return this.parseSubscripts(expr, startLoc);\n  }\n\n  parseSubscripts(\n    this: Parser,\n    base: N.Expression,\n    startLoc: Position,\n    noCalls?: boolean | null,\n  ): N.Expression {\n    const state = {\n      optionalChainMember: false,\n      maybeAsyncArrow: this.atPossibleAsyncArrow(base),\n      stop: false,\n    };\n    do {\n      base = this.parseSubscript(base, startLoc, noCalls, state);\n\n      // After parsing a subscript, this isn't \"async\" for sure.\n      state.maybeAsyncArrow = false;\n    } while (!state.stop);\n    return base;\n  }\n\n  /**\n   * @param state Set 'state.stop = true' to indicate that we should stop parsing subscripts.\n   *   state.optionalChainMember to indicate that the member is currently in OptionalChain\n   */\n  parseSubscript(\n    this: Parser,\n    base: N.Expression,\n    startLoc: Position,\n    noCalls: boolean | undefined | null,\n    state: N.ParseSubscriptState,\n  ): N.Expression {\n    const { type } = this.state;\n    if (!noCalls && type === tt.doubleColon) {\n      return this.parseBind(base, startLoc, noCalls, state);\n    } else if (tokenIsTemplate(type)) {\n      return this.parseTaggedTemplateExpression(base, startLoc, state);\n    }\n\n    let optional = false;\n\n    if (type === tt.questionDot) {\n      if (noCalls) {\n        this.raise(Errors.OptionalChainingNoNew, {\n          at: this.state.startLoc,\n        });\n        if (this.lookaheadCharCode() === charCodes.leftParenthesis) {\n          // stop at `?.` when parsing `new a?.()`\n          state.stop = true;\n          return base;\n        }\n      }\n      state.optionalChainMember = optional = true;\n      this.next();\n    }\n\n    if (!noCalls && this.match(tt.parenL)) {\n      return this.parseCoverCallAndAsyncArrowHead(\n        base,\n        startLoc,\n        state,\n        optional,\n      );\n    } else {\n      const computed = this.eat(tt.bracketL);\n      if (computed || optional || this.eat(tt.dot)) {\n        return this.parseMember(base, startLoc, state, computed, optional);\n      } else {\n        state.stop = true;\n        return base;\n      }\n    }\n  }\n\n  // base[?Yield, ?Await] [ Expression[+In, ?Yield, ?Await] ]\n  // base[?Yield, ?Await] . IdentifierName\n  // base[?Yield, ?Await] . PrivateIdentifier\n  //   where `base` is one of CallExpression, MemberExpression and OptionalChain\n  parseMember(\n    this: Parser,\n    base: N.Expression,\n    startLoc: Position,\n    state: N.ParseSubscriptState,\n    computed: boolean,\n    optional: boolean,\n  ): N.OptionalMemberExpression | N.MemberExpression {\n    const node = this.startNodeAt<\n      N.OptionalMemberExpression | N.MemberExpression\n    >(startLoc);\n    node.object = base;\n    node.computed = computed;\n    if (computed) {\n      node.property = this.parseExpression();\n      this.expect(tt.bracketR);\n    } else if (this.match(tt.privateName)) {\n      if (base.type === \"Super\") {\n        this.raise(Errors.SuperPrivateField, { at: startLoc });\n      }\n      this.classScope.usePrivateName(this.state.value, this.state.startLoc);\n      node.property = this.parsePrivateName();\n    } else {\n      node.property = this.parseIdentifier(true);\n    }\n\n    if (state.optionalChainMember) {\n      (node as N.OptionalMemberExpression).optional = optional;\n      return this.finishNode(node, \"OptionalMemberExpression\");\n    } else {\n      return this.finishNode(node, \"MemberExpression\");\n    }\n  }\n\n  // https://github.com/tc39/proposal-bind-operator#syntax\n  parseBind(\n    this: Parser,\n    base: N.Expression,\n    startLoc: Position,\n    noCalls: boolean | undefined | null,\n    state: N.ParseSubscriptState,\n  ): N.Expression {\n    const node = this.startNodeAt(startLoc);\n    node.object = base;\n    this.next(); // eat '::'\n    node.callee = this.parseNoCallExpr();\n    state.stop = true;\n    return this.parseSubscripts(\n      this.finishNode(node, \"BindExpression\"),\n      startLoc,\n      noCalls,\n    );\n  }\n\n  // https://tc39.es/ecma262/#prod-CoverCallExpressionAndAsyncArrowHead\n  // CoverCallExpressionAndAsyncArrowHead\n  // CallExpression[?Yield, ?Await] Arguments[?Yield, ?Await]\n  // OptionalChain[?Yield, ?Await] Arguments[?Yield, ?Await]\n  parseCoverCallAndAsyncArrowHead(\n    this: Parser,\n    base: N.Expression,\n    startLoc: Position,\n    state: N.ParseSubscriptState,\n    optional: boolean,\n  ): N.Expression {\n    const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;\n    let refExpressionErrors: ExpressionErrors | null = null;\n\n    this.state.maybeInArrowParameters = true;\n    this.next(); // eat `(`\n\n    const node = this.startNodeAt<N.CallExpression | N.OptionalCallExpression>(\n      startLoc,\n    );\n    node.callee = base;\n    const { maybeAsyncArrow, optionalChainMember } = state;\n\n    if (maybeAsyncArrow) {\n      this.expressionScope.enter(newAsyncArrowScope());\n      refExpressionErrors = new ExpressionErrors();\n    }\n\n    if (optionalChainMember) {\n      // @ts-expect-error when optionalChainMember is true, node must be an optional call\n      node.optional = optional;\n    }\n\n    if (optional) {\n      node.arguments = this.parseCallExpressionArguments(tt.parenR);\n    } else {\n      node.arguments = this.parseCallExpressionArguments(\n        tt.parenR,\n        base.type === \"Import\",\n        base.type !== \"Super\",\n        // @ts-expect-error todo(flow->ts)\n        node,\n        refExpressionErrors,\n      );\n    }\n    let finishedNode:\n      | N.CallExpression\n      | N.OptionalCallExpression\n      | N.ArrowFunctionExpression = this.finishCallExpression(\n      node,\n      optionalChainMember,\n    );\n\n    if (maybeAsyncArrow && this.shouldParseAsyncArrow() && !optional) {\n      /*:: invariant(refExpressionErrors != null) */\n      state.stop = true;\n      this.checkDestructuringPrivate(refExpressionErrors);\n      this.expressionScope.validateAsPattern();\n      this.expressionScope.exit();\n      finishedNode = this.parseAsyncArrowFromCallExpression(\n        this.startNodeAt<N.ArrowFunctionExpression>(startLoc),\n        finishedNode as N.CallExpression,\n      );\n    } else {\n      if (maybeAsyncArrow) {\n        this.checkExpressionErrors(refExpressionErrors, true);\n        this.expressionScope.exit();\n      }\n      this.toReferencedArguments(finishedNode);\n    }\n\n    this.state.maybeInArrowParameters = oldMaybeInArrowParameters;\n\n    return finishedNode;\n  }\n\n  toReferencedArguments(\n    node: N.CallExpression | N.OptionalCallExpression,\n    isParenthesizedExpr?: boolean,\n  ) {\n    this.toReferencedListDeep(node.arguments, isParenthesizedExpr);\n  }\n\n  // MemberExpression [?Yield, ?Await] TemplateLiteral[?Yield, ?Await, +Tagged]\n  // CallExpression [?Yield, ?Await] TemplateLiteral[?Yield, ?Await, +Tagged]\n  parseTaggedTemplateExpression(\n    this: Parser,\n    base: N.Expression,\n    startLoc: Position,\n    state: N.ParseSubscriptState,\n  ): N.TaggedTemplateExpression {\n    const node = this.startNodeAt<N.TaggedTemplateExpression>(startLoc);\n    node.tag = base;\n    node.quasi = this.parseTemplate(true);\n    if (state.optionalChainMember) {\n      this.raise(Errors.OptionalChainingNoTemplate, { at: startLoc });\n    }\n    return this.finishNode(node, \"TaggedTemplateExpression\");\n  }\n\n  atPossibleAsyncArrow(base: N.Expression): boolean {\n    return (\n      base.type === \"Identifier\" &&\n      base.name === \"async\" &&\n      this.state.lastTokEndLoc.index === base.end &&\n      !this.canInsertSemicolon() &&\n      // check there are no escape sequences, such as \\u{61}sync\n      base.end - base.start === 5 &&\n      base.start === this.state.potentialArrowAt\n    );\n  }\n\n  expectImportAttributesPlugin() {\n    if (!this.hasPlugin(\"importAssertions\")) {\n      this.expectPlugin(\"importAttributes\");\n    }\n  }\n\n  finishCallExpression<T extends N.CallExpression | N.OptionalCallExpression>(\n    node: Undone<T>,\n    optional: boolean,\n  ): T {\n    if (node.callee.type === \"Import\") {\n      if (node.arguments.length === 2) {\n        if (process.env.BABEL_8_BREAKING) {\n          this.expectImportAttributesPlugin();\n        } else {\n          if (!this.hasPlugin(\"moduleAttributes\")) {\n            this.expectImportAttributesPlugin();\n          }\n        }\n      }\n      if (node.arguments.length === 0 || node.arguments.length > 2) {\n        this.raise(Errors.ImportCallArity, {\n          at: node,\n          maxArgumentCount:\n            this.hasPlugin(\"importAttributes\") ||\n            this.hasPlugin(\"importAssertions\") ||\n            this.hasPlugin(\"moduleAttributes\")\n              ? 2\n              : 1,\n        });\n      } else {\n        for (const arg of node.arguments) {\n          if (arg.type === \"SpreadElement\") {\n            this.raise(Errors.ImportCallSpreadArgument, { at: arg });\n          }\n        }\n      }\n    }\n    return this.finishNode(\n      node,\n      optional ? \"OptionalCallExpression\" : \"CallExpression\",\n    );\n  }\n\n  parseCallExpressionArguments(\n    this: Parser,\n    close: TokenType,\n    dynamicImport?: boolean,\n    allowPlaceholder?: boolean,\n    nodeForExtra?: N.Node | null,\n    refExpressionErrors?: ExpressionErrors | null,\n  ): Array<N.Expression | undefined | null> {\n    const elts: N.Expression[] = [];\n    let first = true;\n    const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;\n    this.state.inFSharpPipelineDirectBody = false;\n\n    while (!this.eat(close)) {\n      if (first) {\n        first = false;\n      } else {\n        this.expect(tt.comma);\n        if (this.match(close)) {\n          if (\n            dynamicImport &&\n            !this.hasPlugin(\"importAttributes\") &&\n            !this.hasPlugin(\"importAssertions\") &&\n            !this.hasPlugin(\"moduleAttributes\")\n          ) {\n            this.raise(Errors.ImportCallArgumentTrailingComma, {\n              at: this.state.lastTokStartLoc,\n            });\n          }\n          if (nodeForExtra) {\n            this.addTrailingCommaExtraToNode(nodeForExtra);\n          }\n          this.next();\n          break;\n        }\n      }\n\n      elts.push(\n        this.parseExprListItem(false, refExpressionErrors, allowPlaceholder),\n      );\n    }\n\n    this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;\n\n    return elts;\n  }\n\n  shouldParseAsyncArrow(): boolean {\n    return this.match(tt.arrow) && !this.canInsertSemicolon();\n  }\n\n  parseAsyncArrowFromCallExpression(\n    this: Parser,\n    node: Undone<N.ArrowFunctionExpression>,\n    call: N.CallExpression,\n  ): N.ArrowFunctionExpression {\n    this.resetPreviousNodeTrailingComments(call);\n    this.expect(tt.arrow);\n    this.parseArrowExpression(\n      node,\n      call.arguments,\n      true,\n      call.extra?.trailingCommaLoc,\n    );\n    // mark inner comments of `async()` as inner comments of `async () =>`\n    if (call.innerComments) {\n      setInnerComments(node, call.innerComments);\n    }\n    // mark trailing comments of `async` to be inner comments\n    if (call.callee.trailingComments) {\n      setInnerComments(node, call.callee.trailingComments);\n    }\n    return node as N.ArrowFunctionExpression;\n  }\n\n  // Parse a no-call expression (like argument of `new` or `::` operators).\n  // https://tc39.es/ecma262/#prod-MemberExpression\n  parseNoCallExpr(this: Parser): N.Expression {\n    const startLoc = this.state.startLoc;\n    return this.parseSubscripts(this.parseExprAtom(), startLoc, true);\n  }\n\n  // Parse an atomic expression — either a single token that is an\n  // expression, an expression started by a keyword like `function` or\n  // `new`, or an expression wrapped in punctuation like `()`, `[]`,\n  // or `{}`.\n\n  // https://tc39.es/ecma262/#prod-PrimaryExpression\n  // https://tc39.es/ecma262/#prod-AsyncArrowFunction\n  // PrimaryExpression\n  // Super\n  // Import\n  // AsyncArrowFunction\n\n  parseExprAtom(\n    this: Parser,\n    refExpressionErrors?: ExpressionErrors | null,\n  ): N.Expression {\n    let node;\n    let decorators: N.Decorator[] | null = null;\n\n    const { type } = this.state;\n    switch (type) {\n      case tt._super:\n        return this.parseSuper();\n\n      case tt._import:\n        node = this.startNode<N.MetaProperty | N.Import>();\n        this.next();\n\n        if (this.match(tt.dot)) {\n          return this.parseImportMetaProperty(node as Undone<N.MetaProperty>);\n        }\n\n        if (!this.match(tt.parenL)) {\n          this.raise(Errors.UnsupportedImport, {\n            at: this.state.lastTokStartLoc,\n          });\n        }\n        return this.finishNode(node, \"Import\");\n      case tt._this:\n        node = this.startNode();\n        this.next();\n        return this.finishNode(node, \"ThisExpression\");\n\n      case tt._do: {\n        return this.parseDo(this.startNode(), false);\n      }\n\n      case tt.slash:\n      case tt.slashAssign: {\n        this.readRegexp();\n        return this.parseRegExpLiteral(this.state.value);\n      }\n\n      case tt.num:\n        return this.parseNumericLiteral(this.state.value);\n\n      case tt.bigint:\n        return this.parseBigIntLiteral(this.state.value);\n\n      case tt.decimal:\n        return this.parseDecimalLiteral(this.state.value);\n\n      case tt.string:\n        return this.parseStringLiteral(this.state.value);\n\n      case tt._null:\n        return this.parseNullLiteral();\n\n      case tt._true:\n        return this.parseBooleanLiteral(true);\n      case tt._false:\n        return this.parseBooleanLiteral(false);\n\n      case tt.parenL: {\n        const canBeArrow = this.state.potentialArrowAt === this.state.start;\n        return this.parseParenAndDistinguishExpression(canBeArrow);\n      }\n\n      case tt.bracketBarL:\n      case tt.bracketHashL: {\n        return this.parseArrayLike(\n          this.state.type === tt.bracketBarL ? tt.bracketBarR : tt.bracketR,\n          /* canBePattern */ false,\n          /* isTuple */ true,\n        );\n      }\n      case tt.bracketL: {\n        return this.parseArrayLike(\n          tt.bracketR,\n          /* canBePattern */ true,\n          /* isTuple */ false,\n          refExpressionErrors,\n        );\n      }\n      case tt.braceBarL:\n      case tt.braceHashL: {\n        return this.parseObjectLike(\n          this.state.type === tt.braceBarL ? tt.braceBarR : tt.braceR,\n          /* isPattern */ false,\n          /* isRecord */ true,\n        );\n      }\n      case tt.braceL: {\n        return this.parseObjectLike(\n          tt.braceR,\n          /* isPattern */ false,\n          /* isRecord */ false,\n          refExpressionErrors,\n        );\n      }\n      case tt._function:\n        return this.parseFunctionOrFunctionSent();\n\n      case tt.at:\n        decorators = this.parseDecorators();\n      // fall through\n      case tt._class:\n        return this.parseClass(\n          this.maybeTakeDecorators(decorators, this.startNode()),\n          false,\n        );\n\n      case tt._new:\n        return this.parseNewOrNewTarget();\n\n      case tt.templateNonTail:\n      case tt.templateTail:\n        return this.parseTemplate(false);\n\n      // BindExpression[Yield]\n      //   :: MemberExpression[?Yield]\n      case tt.doubleColon: {\n        node = this.startNode();\n        this.next();\n        node.object = null;\n        const callee = (node.callee = this.parseNoCallExpr());\n        if (callee.type === \"MemberExpression\") {\n          return this.finishNode(node, \"BindExpression\");\n        } else {\n          throw this.raise(Errors.UnsupportedBind, { at: callee });\n        }\n      }\n\n      case tt.privateName: {\n        // Standalone private names are only allowed in \"#x in obj\"\n        // expressions, and they are directly handled by callers of\n        // parseExprOp. If we reach this, the input is always invalid.\n        // We can throw a better error message and recover, rather than\n        // just throwing \"Unexpected token\" (which is the default\n        // behavior of this big switch statement).\n        this.raise(Errors.PrivateInExpectedIn, {\n          at: this.state.startLoc,\n          identifierName: this.state.value,\n        });\n        return this.parsePrivateName();\n      }\n\n      case tt.moduloAssign: {\n        return this.parseTopicReferenceThenEqualsSign(tt.modulo, \"%\");\n      }\n\n      case tt.xorAssign: {\n        return this.parseTopicReferenceThenEqualsSign(tt.bitwiseXOR, \"^\");\n      }\n\n      case tt.doubleCaret:\n      case tt.doubleAt: {\n        return this.parseTopicReference(\"hack\");\n      }\n\n      case tt.bitwiseXOR:\n      case tt.modulo:\n      case tt.hash: {\n        const pipeProposal = this.getPluginOption(\n          \"pipelineOperator\",\n          \"proposal\",\n        );\n\n        if (pipeProposal) {\n          return this.parseTopicReference(pipeProposal);\n        }\n        this.unexpected();\n        break;\n      }\n\n      case tt.lt: {\n        const lookaheadCh = this.input.codePointAt(this.nextTokenStart());\n        if (\n          isIdentifierStart(lookaheadCh) || // Element/Type Parameter <foo>\n          lookaheadCh === charCodes.greaterThan // Fragment <>\n        ) {\n          this.expectOnePlugin([\"jsx\", \"flow\", \"typescript\"]);\n        } else {\n          this.unexpected();\n        }\n        break;\n      }\n\n      default:\n        if (tokenIsIdentifier(type)) {\n          if (\n            this.isContextual(tt._module) &&\n            this.lookaheadInLineCharCode() === charCodes.leftCurlyBrace\n          ) {\n            return this.parseModuleExpression();\n          }\n          const canBeArrow = this.state.potentialArrowAt === this.state.start;\n          const containsEsc = this.state.containsEsc;\n          const id = this.parseIdentifier();\n\n          if (\n            !containsEsc &&\n            id.name === \"async\" &&\n            !this.canInsertSemicolon()\n          ) {\n            const { type } = this.state;\n            if (type === tt._function) {\n              this.resetPreviousNodeTrailingComments(id);\n              this.next();\n              return this.parseAsyncFunctionExpression(\n                this.startNodeAtNode(id),\n              );\n            } else if (tokenIsIdentifier(type)) {\n              // If the next token begins with \"=\", commit to parsing an async\n              // arrow function. (Peeking ahead for \"=\" lets us avoid a more\n              // expensive full-token lookahead on this common path.)\n              if (this.lookaheadCharCode() === charCodes.equalsTo) {\n                // although `id` is not used in async arrow unary function,\n                // we don't need to reset `async`'s trailing comments because\n                // it will be attached to the upcoming async arrow binding identifier\n                return this.parseAsyncArrowUnaryFunction(\n                  this.startNodeAtNode(id),\n                );\n              } else {\n                // Otherwise, treat \"async\" as an identifier and let calling code\n                // deal with the current tt.name token.\n                return id;\n              }\n            } else if (type === tt._do) {\n              this.resetPreviousNodeTrailingComments(id);\n              return this.parseDo(this.startNodeAtNode(id), true);\n            }\n          }\n\n          if (\n            canBeArrow &&\n            this.match(tt.arrow) &&\n            !this.canInsertSemicolon()\n          ) {\n            this.next();\n            return this.parseArrowExpression(\n              this.startNodeAtNode(id),\n              [id],\n              false,\n            );\n          }\n\n          return id;\n        } else {\n          this.unexpected();\n        }\n    }\n  }\n\n  // This helper method should only be called\n  // when the parser has reached a potential Hack pipe topic token\n  // that is followed by an equals sign.\n  // See <https://github.com/js-choi/proposal-hack-pipes>.\n  // If we find ^= or %= in an expression position\n  // (i.e., the tt.moduloAssign or tt.xorAssign token types), and if the\n  // Hack-pipes proposal is active with ^ or % as its topicToken, then the ^ or\n  // % could be the topic token (e.g., in x |> ^==y or x |> ^===y), and so we\n  // reparse the current token as ^ or %.\n  // Otherwise, this throws an unexpected-token error.\n  parseTopicReferenceThenEqualsSign(\n    topicTokenType: TokenType,\n    topicTokenValue: string,\n  ): N.Expression {\n    const pipeProposal = this.getPluginOption(\"pipelineOperator\", \"proposal\");\n\n    if (pipeProposal) {\n      // Set the most-recent token to be a topic token\n      // given by the tokenType and tokenValue.\n      // Now the next readToken() call (in parseTopicReference)\n      // will consume that “topic token”.\n      this.state.type = topicTokenType;\n      this.state.value = topicTokenValue;\n      // Rewind the tokenizer to the end of the “topic token”, so that the\n      // following token starts at the equals sign after that topic token.\n      this.state.pos--;\n      this.state.end--;\n      // This is safe to do since the preceding character was either ^ or %, and\n      // thus not a newline.\n      this.state.endLoc = createPositionWithColumnOffset(this.state.endLoc, -1);\n      // Now actually consume the topic token.\n      return this.parseTopicReference(pipeProposal);\n    } else {\n      this.unexpected();\n    }\n  }\n\n  // This helper method should only be called\n  // when the proposal-pipeline-operator plugin is active,\n  // and when the parser has reached a potential Hack pipe topic token.\n  // Although a pipe-operator proposal is assumed to be active,\n  // its configuration might not match the current token’s type.\n  // See <https://github.com/js-choi/proposal-hack-pipes>.\n  parseTopicReference(pipeProposal: string): N.Expression {\n    const node = this.startNode<N.TopicReference>();\n    const startLoc = this.state.startLoc;\n    const tokenType = this.state.type;\n\n    // Consume the current token.\n    this.next();\n\n    // If the pipe-operator plugin’s configuration matches the current token’s type,\n    // then this will return `node`, will have been finished as a topic reference.\n    // Otherwise, this will throw a `PipeTopicUnconfiguredToken` error.\n    return this.finishTopicReference(node, startLoc, pipeProposal, tokenType);\n  }\n\n  // This helper method attempts to finish the given `node`\n  // into a topic-reference node for the given `pipeProposal`.\n  // See <https://github.com/js-choi/proposal-hack-pipes>.\n  //\n  // The method assumes that any topic token was consumed before it was called.\n  //\n  // If the `pipelineOperator` plugin is active,\n  // and if the given `tokenType` matches the plugin’s configuration,\n  // then this method will return the finished `node`.\n  //\n  // If the `pipelineOperator` plugin is active,\n  // but if the given `tokenType` does not match the plugin’s configuration,\n  // then this method will throw a `PipeTopicUnconfiguredToken` error.\n  finishTopicReference(\n    node: Undone<N.Node>,\n    startLoc: Position,\n    pipeProposal: string,\n    tokenType: TokenType,\n  ): N.Expression {\n    if (\n      this.testTopicReferenceConfiguration(pipeProposal, startLoc, tokenType)\n    ) {\n      // The token matches the plugin’s configuration.\n      // The token is therefore a topic reference.\n\n      // Determine the node type for the topic reference\n      // that is appropriate for the active pipe-operator proposal.\n      const nodeType =\n        pipeProposal === \"smart\"\n          ? \"PipelinePrimaryTopicReference\"\n          : // The proposal must otherwise be \"hack\",\n            // as enforced by testTopicReferenceConfiguration.\n            \"TopicReference\";\n\n      if (!this.topicReferenceIsAllowedInCurrentContext()) {\n        this.raise(\n          // The topic reference is not allowed in the current context:\n          // it is outside of a pipe body.\n          // Raise recoverable errors.\n          pipeProposal === \"smart\"\n            ? Errors.PrimaryTopicNotAllowed\n            : // In this case, `pipeProposal === \"hack\"` is true.\n              Errors.PipeTopicUnbound,\n          { at: startLoc },\n        );\n      }\n\n      // Register the topic reference so that its pipe body knows\n      // that its topic was used at least once.\n      this.registerTopicReference();\n\n      return this.finishNode(node, nodeType);\n    } else {\n      // The token does not match the plugin’s configuration.\n      throw this.raise(Errors.PipeTopicUnconfiguredToken, {\n        at: startLoc,\n        token: tokenLabelName(tokenType),\n      });\n    }\n  }\n\n  // This helper method tests whether the given token type\n  // matches the pipelineOperator parser plugin’s configuration.\n  // If the active pipe proposal is Hack style,\n  // and if the given token is the same as the plugin configuration’s `topicToken`,\n  // then this is a valid topic reference.\n  // If the active pipe proposal is smart mix,\n  // then the topic token must always be `#`.\n  // If the active pipe proposal is neither (e.g., \"minimal\" or \"fsharp\"),\n  // then an error is thrown.\n  testTopicReferenceConfiguration(\n    pipeProposal: string,\n    startLoc: Position,\n    tokenType: TokenType,\n  ): boolean {\n    switch (pipeProposal) {\n      case \"hack\": {\n        return this.hasPlugin([\n          \"pipelineOperator\",\n          {\n            // @ts-expect-error token must have a label\n            topicToken: tokenLabelName(tokenType),\n          },\n        ]);\n      }\n      case \"smart\":\n        return tokenType === tt.hash;\n      default:\n        throw this.raise(Errors.PipeTopicRequiresHackPipes, { at: startLoc });\n    }\n  }\n\n  // async [no LineTerminator here] AsyncArrowBindingIdentifier[?Yield] [no LineTerminator here] => AsyncConciseBody[?In]\n  parseAsyncArrowUnaryFunction(\n    this: Parser,\n    node: Undone<N.ArrowFunctionExpression>,\n  ): N.ArrowFunctionExpression {\n    // We don't need to push a new ParameterDeclarationScope here since we are sure\n    // 1) it is an async arrow, 2) no biding pattern is allowed in params\n    this.prodParam.enter(functionFlags(true, this.prodParam.hasYield));\n    const params = [this.parseIdentifier()];\n    this.prodParam.exit();\n    if (this.hasPrecedingLineBreak()) {\n      this.raise(Errors.LineTerminatorBeforeArrow, {\n        at: this.state.curPosition(),\n      });\n    }\n    this.expect(tt.arrow);\n    // let foo = async bar => {};\n    return this.parseArrowExpression(node, params, true);\n  }\n\n  // https://github.com/tc39/proposal-do-expressions\n  // https://github.com/tc39/proposal-async-do-expressions\n  parseDo(\n    this: Parser,\n    node: Undone<N.DoExpression>,\n    isAsync: boolean,\n  ): N.DoExpression {\n    this.expectPlugin(\"doExpressions\");\n    if (isAsync) {\n      this.expectPlugin(\"asyncDoExpressions\");\n    }\n    node.async = isAsync;\n    this.next(); // eat `do`\n    const oldLabels = this.state.labels;\n    this.state.labels = [];\n    if (isAsync) {\n      // AsyncDoExpression :\n      // async [no LineTerminator here] do Block[~Yield, +Await, ~Return]\n      this.prodParam.enter(PARAM_AWAIT);\n      node.body = this.parseBlock();\n      this.prodParam.exit();\n    } else {\n      node.body = this.parseBlock();\n    }\n\n    this.state.labels = oldLabels;\n    return this.finishNode(node, \"DoExpression\");\n  }\n\n  // Parse the `super` keyword\n  parseSuper(): N.Super {\n    const node = this.startNode<N.Super>();\n    this.next(); // eat `super`\n    if (\n      this.match(tt.parenL) &&\n      !this.scope.allowDirectSuper &&\n      !this.options.allowSuperOutsideMethod\n    ) {\n      this.raise(Errors.SuperNotAllowed, { at: node });\n    } else if (\n      !this.scope.allowSuper &&\n      !this.options.allowSuperOutsideMethod\n    ) {\n      this.raise(Errors.UnexpectedSuper, { at: node });\n    }\n\n    if (\n      !this.match(tt.parenL) &&\n      !this.match(tt.bracketL) &&\n      !this.match(tt.dot)\n    ) {\n      this.raise(Errors.UnsupportedSuper, { at: node });\n    }\n\n    return this.finishNode(node, \"Super\");\n  }\n\n  parsePrivateName(): N.PrivateName {\n    const node = this.startNode<N.PrivateName>();\n    const id = this.startNodeAt<N.Identifier>(\n      // The position is hardcoded because we merge `#` and name into a single\n      // tt.privateName token\n      createPositionWithColumnOffset(this.state.startLoc, 1),\n    );\n    const name = this.state.value;\n    this.next(); // eat #name;\n    node.id = this.createIdentifier(id, name);\n    return this.finishNode(node, \"PrivateName\");\n  }\n\n  parseFunctionOrFunctionSent(\n    this: Parser,\n  ): N.FunctionExpression | N.MetaProperty {\n    const node = this.startNode<N.FunctionExpression | N.MetaProperty>();\n\n    // We do not do parseIdentifier here because when parseFunctionOrFunctionSent\n    // is called we already know that the current token is a \"name\" with the value \"function\"\n    // This will improve perf a tiny little bit as we do not do validation but more importantly\n    // here is that parseIdentifier will remove an item from the expression stack\n    // if \"function\" or \"class\" is parsed as identifier (in objects e.g.), which should not happen here.\n    this.next(); // eat `function`\n\n    if (this.prodParam.hasYield && this.match(tt.dot)) {\n      const meta = this.createIdentifier(\n        this.startNodeAtNode<N.Identifier>(node),\n        \"function\",\n      );\n      this.next(); // eat `.`\n      // https://github.com/tc39/proposal-function.sent#syntax-1\n      if (this.match(tt._sent)) {\n        this.expectPlugin(\"functionSent\");\n      } else if (!this.hasPlugin(\"functionSent\")) {\n        // The code wasn't `function.sent` but just `function.`, so a simple error is less confusing.\n        this.unexpected();\n      }\n      return this.parseMetaProperty(\n        node as Undone<N.MetaProperty>,\n        meta,\n        \"sent\",\n      );\n    }\n    return this.parseFunction(node as Undone<N.FunctionExpression>);\n  }\n\n  parseMetaProperty(\n    node: Undone<N.MetaProperty>,\n    meta: N.Identifier,\n    propertyName: string,\n  ): N.MetaProperty {\n    node.meta = meta;\n\n    const containsEsc = this.state.containsEsc;\n\n    node.property = this.parseIdentifier(true);\n\n    if (node.property.name !== propertyName || containsEsc) {\n      this.raise(Errors.UnsupportedMetaProperty, {\n        at: node.property,\n        target: meta.name,\n        onlyValidPropertyName: propertyName,\n      });\n    }\n\n    return this.finishNode(node, \"MetaProperty\");\n  }\n\n  // https://tc39.es/ecma262/#prod-ImportMeta\n  parseImportMetaProperty(node: Undone<N.MetaProperty>): N.MetaProperty {\n    const id = this.createIdentifier(\n      this.startNodeAtNode<N.Identifier>(node),\n      \"import\",\n    );\n    this.next(); // eat `.`\n\n    if (this.isContextual(tt._meta)) {\n      if (!this.inModule) {\n        this.raise(Errors.ImportMetaOutsideModule, { at: id });\n      }\n      this.sawUnambiguousESM = true;\n    }\n\n    return this.parseMetaProperty(node, id, \"meta\");\n  }\n\n  parseLiteralAtNode<T extends N.Node>(\n    value: any,\n    type: T[\"type\"],\n    node: any,\n  ): T {\n    this.addExtra(node, \"rawValue\", value);\n    this.addExtra(node, \"raw\", this.input.slice(node.start, this.state.end));\n    node.value = value;\n    this.next();\n    return this.finishNode<T>(node, type);\n  }\n\n  parseLiteral<T extends N.Node>(value: any, type: T[\"type\"]): T {\n    const node = this.startNode();\n    return this.parseLiteralAtNode(value, type, node);\n  }\n\n  parseStringLiteral(value: any) {\n    return this.parseLiteral<N.StringLiteral>(value, \"StringLiteral\");\n  }\n\n  parseNumericLiteral(value: any) {\n    return this.parseLiteral<N.NumericLiteral>(value, \"NumericLiteral\");\n  }\n\n  parseBigIntLiteral(value: any) {\n    return this.parseLiteral<N.BigIntLiteral>(value, \"BigIntLiteral\");\n  }\n\n  parseDecimalLiteral(value: any) {\n    return this.parseLiteral<N.DecimalLiteral>(value, \"DecimalLiteral\");\n  }\n\n  parseRegExpLiteral(value: {\n    value: any;\n    pattern: string;\n    flags: N.RegExpLiteral[\"flags\"];\n  }) {\n    const node = this.parseLiteral<N.RegExpLiteral>(\n      value.value,\n      \"RegExpLiteral\",\n    );\n    node.pattern = value.pattern;\n    node.flags = value.flags;\n    return node;\n  }\n\n  parseBooleanLiteral(value: boolean) {\n    const node = this.startNode<N.BooleanLiteral>();\n    node.value = value;\n    this.next();\n    return this.finishNode(node, \"BooleanLiteral\");\n  }\n\n  parseNullLiteral() {\n    const node = this.startNode<N.NullLiteral>();\n    this.next();\n    return this.finishNode(node, \"NullLiteral\");\n  }\n\n  // https://tc39.es/ecma262/#prod-CoverParenthesizedExpressionAndArrowParameterList\n  parseParenAndDistinguishExpression(\n    this: Parser,\n    canBeArrow: boolean,\n  ): N.Expression {\n    const startLoc = this.state.startLoc;\n\n    let val;\n    this.next(); // eat `(`\n    this.expressionScope.enter(newArrowHeadScope());\n\n    const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;\n    const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;\n    this.state.maybeInArrowParameters = true;\n    this.state.inFSharpPipelineDirectBody = false;\n\n    const innerStartLoc = this.state.startLoc;\n    const exprList: N.Expression[] = [];\n    const refExpressionErrors = new ExpressionErrors();\n    let first = true;\n    let spreadStartLoc;\n    let optionalCommaStartLoc;\n\n    while (!this.match(tt.parenR)) {\n      if (first) {\n        first = false;\n      } else {\n        this.expect(\n          tt.comma,\n          refExpressionErrors.optionalParametersLoc === null\n            ? null\n            : refExpressionErrors.optionalParametersLoc,\n        );\n        if (this.match(tt.parenR)) {\n          optionalCommaStartLoc = this.state.startLoc;\n          break;\n        }\n      }\n\n      if (this.match(tt.ellipsis)) {\n        const spreadNodeStartLoc = this.state.startLoc;\n        spreadStartLoc = this.state.startLoc;\n        exprList.push(\n          this.parseParenItem(this.parseRestBinding(), spreadNodeStartLoc),\n        );\n\n        if (!this.checkCommaAfterRest(charCodes.rightParenthesis)) {\n          break;\n        }\n      } else {\n        exprList.push(\n          this.parseMaybeAssignAllowIn(\n            refExpressionErrors,\n            this.parseParenItem,\n          ),\n        );\n      }\n    }\n\n    const innerEndLoc = this.state.lastTokEndLoc;\n    this.expect(tt.parenR);\n\n    this.state.maybeInArrowParameters = oldMaybeInArrowParameters;\n    this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;\n\n    let arrowNode = this.startNodeAt<N.ArrowFunctionExpression>(startLoc);\n    if (\n      canBeArrow &&\n      this.shouldParseArrow(exprList) &&\n      (arrowNode = this.parseArrow(arrowNode))\n    ) {\n      this.checkDestructuringPrivate(refExpressionErrors);\n      this.expressionScope.validateAsPattern();\n      this.expressionScope.exit();\n      this.parseArrowExpression(arrowNode, exprList, false);\n      // @ts-expect-error todo(flow->ts) improve node types\n      return arrowNode;\n    }\n    this.expressionScope.exit();\n\n    if (!exprList.length) {\n      this.unexpected(this.state.lastTokStartLoc);\n    }\n    if (optionalCommaStartLoc) this.unexpected(optionalCommaStartLoc);\n    if (spreadStartLoc) this.unexpected(spreadStartLoc);\n    this.checkExpressionErrors(refExpressionErrors, true);\n\n    this.toReferencedListDeep(exprList, /* isParenthesizedExpr */ true);\n    if (exprList.length > 1) {\n      val = this.startNodeAt<N.SequenceExpression>(innerStartLoc);\n      val.expressions = exprList;\n      // finish node at current location so it can pick up comments after `)`\n      this.finishNode(val, \"SequenceExpression\");\n      this.resetEndLocation(val, innerEndLoc);\n    } else {\n      val = exprList[0];\n    }\n\n    return this.wrapParenthesis(\n      startLoc,\n      // @ts-expect-error todo(flow->ts)\n      val,\n    );\n  }\n\n  wrapParenthesis(startLoc: Position, expression: N.Expression): N.Expression {\n    if (!this.options.createParenthesizedExpressions) {\n      this.addExtra(expression, \"parenthesized\", true);\n      this.addExtra(expression, \"parenStart\", startLoc.index);\n\n      this.takeSurroundingComments(\n        expression,\n        startLoc.index,\n        this.state.lastTokEndLoc.index,\n      );\n\n      return expression;\n    }\n\n    const parenExpression =\n      this.startNodeAt<N.ParenthesizedExpression>(startLoc);\n    parenExpression.expression = expression;\n    return this.finishNode(parenExpression, \"ParenthesizedExpression\");\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars -- `params` is used in typescript plugin\n  shouldParseArrow(params: Array<N.Node>): boolean {\n    return !this.canInsertSemicolon();\n  }\n\n  parseArrow(\n    node: Undone<N.ArrowFunctionExpression>,\n  ): Undone<N.ArrowFunctionExpression> | undefined {\n    if (this.eat(tt.arrow)) {\n      return node;\n    }\n  }\n\n  parseParenItem(\n    node: N.Expression,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    startLoc: Position,\n  ): N.Expression {\n    return node;\n  }\n\n  parseNewOrNewTarget(this: Parser): N.NewExpression | N.MetaProperty {\n    const node = this.startNode<N.NewExpression | N.MetaProperty>();\n    this.next();\n    if (this.match(tt.dot)) {\n      // https://tc39.es/ecma262/#prod-NewTarget\n      const meta = this.createIdentifier(\n        this.startNodeAtNode<N.Identifier>(node),\n        \"new\",\n      );\n      this.next();\n      const metaProp = this.parseMetaProperty(\n        node as Undone<N.MetaProperty>,\n        meta,\n        \"target\",\n      );\n\n      if (\n        !this.scope.inNonArrowFunction &&\n        !this.scope.inClass &&\n        !this.options.allowNewTargetOutsideFunction\n      ) {\n        this.raise(Errors.UnexpectedNewTarget, { at: metaProp });\n      }\n\n      return metaProp;\n    }\n\n    return this.parseNew(node as Undone<N.NewExpression>);\n  }\n\n  // New's precedence is slightly tricky. It must allow its argument to\n  // be a `[]` or dot subscript expression, but not a call — at least,\n  // not without wrapping it in parentheses. Thus, it uses the noCalls\n  // argument to parseSubscripts to prevent it from consuming the\n  // argument list.\n  // https://tc39.es/ecma262/#prod-NewExpression\n  parseNew(this: Parser, node: Undone<N.NewExpression>): N.NewExpression {\n    this.parseNewCallee(node);\n\n    if (this.eat(tt.parenL)) {\n      const args = this.parseExprList(tt.parenR);\n      this.toReferencedList(args);\n      // (parseExprList should be all non-null in this case)\n      node.arguments = args;\n    } else {\n      node.arguments = [];\n    }\n\n    return this.finishNode(node, \"NewExpression\");\n  }\n\n  parseNewCallee(this: Parser, node: Undone<N.NewExpression>): void {\n    node.callee = this.parseNoCallExpr();\n    if (node.callee.type === \"Import\") {\n      this.raise(Errors.ImportCallNotNewExpression, { at: node.callee });\n    }\n  }\n\n  // Parse template expression.\n\n  parseTemplateElement(isTagged: boolean): N.TemplateElement {\n    const { start, startLoc, end, value } = this.state;\n    const elemStart = start + 1;\n    const elem = this.startNodeAt<N.TemplateElement>(\n      createPositionWithColumnOffset(startLoc, 1),\n    );\n    if (value === null) {\n      if (!isTagged) {\n        this.raise(Errors.InvalidEscapeSequenceTemplate, {\n          // FIXME: Adding 1 is probably wrong.\n          at: createPositionWithColumnOffset(\n            this.state.firstInvalidTemplateEscapePos,\n            1,\n          ),\n        });\n      }\n    }\n\n    const isTail = this.match(tt.templateTail);\n    const endOffset = isTail ? -1 : -2;\n    const elemEnd = end + endOffset;\n    elem.value = {\n      raw: this.input.slice(elemStart, elemEnd).replace(/\\r\\n?/g, \"\\n\"),\n      cooked: value === null ? null : value.slice(1, endOffset),\n    };\n    elem.tail = isTail;\n    this.next();\n    const finishedNode = this.finishNode(elem, \"TemplateElement\");\n    this.resetEndLocation(\n      finishedNode,\n      createPositionWithColumnOffset(this.state.lastTokEndLoc, endOffset),\n    );\n    return finishedNode;\n  }\n\n  // https://tc39.es/ecma262/#prod-TemplateLiteral\n  parseTemplate(this: Parser, isTagged: boolean): N.TemplateLiteral {\n    const node = this.startNode<N.TemplateLiteral>();\n    node.expressions = [];\n    let curElt = this.parseTemplateElement(isTagged);\n    node.quasis = [curElt];\n    while (!curElt.tail) {\n      node.expressions.push(this.parseTemplateSubstitution());\n      this.readTemplateContinuation();\n      node.quasis.push((curElt = this.parseTemplateElement(isTagged)));\n    }\n    return this.finishNode(node, \"TemplateLiteral\");\n  }\n\n  // This is overwritten by the TypeScript plugin to parse template types\n  parseTemplateSubstitution(this: Parser): N.Expression {\n    return this.parseExpression();\n  }\n\n  // Parse an object literal, binding pattern, or record.\n\n  parseObjectLike(\n    close: TokenType,\n    isPattern: true,\n    isRecord?: boolean | null,\n    refExpressionErrors?: ExpressionErrors | null,\n  ): N.ObjectPattern;\n  parseObjectLike(\n    close: TokenType,\n    isPattern: false,\n    isRecord?: false | null,\n    refExpressionErrors?: ExpressionErrors | null,\n  ): N.ObjectExpression;\n  parseObjectLike(\n    close: TokenType,\n    isPattern: false,\n    isRecord?: true,\n    refExpressionErrors?: ExpressionErrors | null,\n  ): N.RecordExpression;\n  parseObjectLike<T extends N.ObjectPattern | N.ObjectExpression>(\n    this: Parser,\n    close: TokenType,\n    isPattern: boolean,\n    isRecord?: boolean | null,\n    refExpressionErrors?: ExpressionErrors | null,\n  ): T {\n    if (isRecord) {\n      this.expectPlugin(\"recordAndTuple\");\n    }\n    const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;\n    this.state.inFSharpPipelineDirectBody = false;\n    const propHash: any = Object.create(null);\n    let first = true;\n    const node = this.startNode<\n      N.ObjectExpression | N.ObjectPattern | N.RecordExpression\n    >();\n\n    node.properties = [];\n    this.next();\n\n    while (!this.match(close)) {\n      if (first) {\n        first = false;\n      } else {\n        this.expect(tt.comma);\n        if (this.match(close)) {\n          this.addTrailingCommaExtraToNode(\n            // @ts-expect-error todo(flow->ts) improve node types\n            node,\n          );\n          break;\n        }\n      }\n\n      let prop;\n      if (isPattern) {\n        prop = this.parseBindingProperty();\n      } else {\n        prop = this.parsePropertyDefinition(refExpressionErrors);\n        this.checkProto(prop, isRecord, propHash, refExpressionErrors);\n      }\n\n      if (\n        isRecord &&\n        !this.isObjectProperty(prop) &&\n        prop.type !== \"SpreadElement\"\n      ) {\n        this.raise(Errors.InvalidRecordProperty, { at: prop });\n      }\n\n      // @ts-expect-error shorthand may not index prop\n      if (prop.shorthand) {\n        this.addExtra(prop, \"shorthand\", true);\n      }\n\n      // @ts-expect-error Fixme: refine typings\n      node.properties.push(prop);\n    }\n\n    this.next();\n\n    this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;\n    let type = \"ObjectExpression\";\n    if (isPattern) {\n      type = \"ObjectPattern\";\n    } else if (isRecord) {\n      type = \"RecordExpression\";\n    }\n    // @ts-expect-error type is well defined\n    return this.finishNode(node, type);\n  }\n\n  addTrailingCommaExtraToNode(node: N.Node): void {\n    this.addExtra(node, \"trailingComma\", this.state.lastTokStart);\n    this.addExtra(node, \"trailingCommaLoc\", this.state.lastTokStartLoc, false);\n  }\n\n  // Check grammar production:\n  //   IdentifierName *_opt PropertyName\n  // It is used in `parsePropertyDefinition` to detect AsyncMethod and Accessors\n  maybeAsyncOrAccessorProp(prop: Undone<N.ObjectProperty>): boolean {\n    return (\n      !prop.computed &&\n      prop.key.type === \"Identifier\" &&\n      (this.isLiteralPropertyName() ||\n        this.match(tt.bracketL) ||\n        this.match(tt.star))\n    );\n  }\n\n  // https://tc39.es/ecma262/#prod-PropertyDefinition\n  parsePropertyDefinition(\n    this: Parser,\n    refExpressionErrors?: ExpressionErrors | null,\n  ): N.ObjectMember | N.SpreadElement {\n    let decorators = [];\n    if (this.match(tt.at)) {\n      if (this.hasPlugin(\"decorators\")) {\n        this.raise(Errors.UnsupportedPropertyDecorator, {\n          at: this.state.startLoc,\n        });\n      }\n\n      // we needn't check if decorators (stage 0) plugin is enabled since it's checked by\n      // the call to this.parseDecorator\n      while (this.match(tt.at)) {\n        decorators.push(this.parseDecorator());\n      }\n    }\n\n    const prop = this.startNode<N.ObjectProperty>();\n    let isAsync = false;\n    let isAccessor = false;\n    let startLoc;\n\n    if (this.match(tt.ellipsis)) {\n      if (decorators.length) this.unexpected();\n      return this.parseSpread();\n    }\n\n    if (decorators.length) {\n      prop.decorators = decorators;\n      decorators = [];\n    }\n\n    prop.method = false;\n\n    if (refExpressionErrors) {\n      startLoc = this.state.startLoc;\n    }\n\n    let isGenerator = this.eat(tt.star);\n    this.parsePropertyNamePrefixOperator(prop);\n    const containsEsc = this.state.containsEsc;\n    const key = this.parsePropertyName(prop, refExpressionErrors);\n\n    if (!isGenerator && !containsEsc && this.maybeAsyncOrAccessorProp(prop)) {\n      const keyName = key.name;\n      // https://tc39.es/ecma262/#prod-AsyncMethod\n      // https://tc39.es/ecma262/#prod-AsyncGeneratorMethod\n      if (keyName === \"async\" && !this.hasPrecedingLineBreak()) {\n        isAsync = true;\n        this.resetPreviousNodeTrailingComments(key);\n        isGenerator = this.eat(tt.star);\n        this.parsePropertyName(prop);\n      }\n      // get PropertyName[?Yield, ?Await] () { FunctionBody[~Yield, ~Await] }\n      // set PropertyName[?Yield, ?Await] ( PropertySetParameterList ) { FunctionBody[~Yield, ~Await] }\n      if (keyName === \"get\" || keyName === \"set\") {\n        isAccessor = true;\n        this.resetPreviousNodeTrailingComments(key);\n        prop.kind = keyName;\n        if (this.match(tt.star)) {\n          isGenerator = true;\n          this.raise(Errors.AccessorIsGenerator, {\n            at: this.state.curPosition(),\n            kind: keyName,\n          });\n          this.next();\n        }\n        this.parsePropertyName(prop);\n      }\n    }\n\n    return this.parseObjPropValue(\n      prop,\n      startLoc,\n      isGenerator,\n      isAsync,\n      false /* isPattern */,\n      isAccessor,\n      refExpressionErrors,\n    );\n  }\n\n  getGetterSetterExpectedParamCount(\n    method: N.ObjectMethod | N.ClassMethod,\n  ): number {\n    return method.kind === \"get\" ? 0 : 1;\n  }\n\n  // This exists so we can override within the ESTree plugin\n  getObjectOrClassMethodParams(method: N.ObjectMethod | N.ClassMethod) {\n    return method.params;\n  }\n\n  // get methods aren't allowed to have any parameters\n  // set methods must have exactly 1 parameter which is not a rest parameter\n  checkGetterSetterParams(method: N.ObjectMethod | N.ClassMethod): void {\n    const paramCount = this.getGetterSetterExpectedParamCount(method);\n    const params = this.getObjectOrClassMethodParams(method);\n\n    if (params.length !== paramCount) {\n      this.raise(\n        method.kind === \"get\" ? Errors.BadGetterArity : Errors.BadSetterArity,\n        { at: method },\n      );\n    }\n\n    if (\n      method.kind === \"set\" &&\n      params[params.length - 1]?.type === \"RestElement\"\n    ) {\n      this.raise(Errors.BadSetterRestParameter, { at: method });\n    }\n  }\n\n  // https://tc39.es/ecma262/#prod-MethodDefinition\n  parseObjectMethod(\n    this: Parser,\n    prop: Undone<N.ObjectMethod>,\n    isGenerator: boolean,\n    isAsync: boolean,\n    isPattern: boolean,\n    isAccessor: boolean,\n  ): N.ObjectMethod | undefined | null {\n    if (isAccessor) {\n      // isAccessor implies isAsync: false, isPattern: false, isGenerator: false\n      const finishedProp = this.parseMethod(\n        prop,\n        // This _should_ be false, but with error recovery, we allow it to be\n        // set for informational purposes\n        isGenerator,\n        /* isAsync */ false,\n        /* isConstructor */ false,\n        false,\n        \"ObjectMethod\",\n      );\n      this.checkGetterSetterParams(finishedProp);\n      return finishedProp;\n    }\n\n    if (isAsync || isGenerator || this.match(tt.parenL)) {\n      if (isPattern) this.unexpected();\n      prop.kind = \"method\";\n      prop.method = true;\n      return this.parseMethod(\n        prop,\n        isGenerator,\n        isAsync,\n        /* isConstructor */ false,\n        false,\n        \"ObjectMethod\",\n      );\n    }\n  }\n\n  // if `isPattern` is true, parse https://tc39.es/ecma262/#prod-BindingProperty\n  // else https://tc39.es/ecma262/#prod-PropertyDefinition\n  parseObjectProperty(\n    this: Parser,\n    prop: Undone<N.ObjectProperty>,\n    startLoc: Position | undefined | null,\n    isPattern: boolean,\n    refExpressionErrors?: ExpressionErrors | null,\n  ): N.ObjectProperty | undefined | null {\n    prop.shorthand = false;\n\n    if (this.eat(tt.colon)) {\n      prop.value = isPattern\n        ? this.parseMaybeDefault(this.state.startLoc)\n        : this.parseMaybeAssignAllowIn(refExpressionErrors);\n\n      return this.finishNode(prop, \"ObjectProperty\");\n    }\n\n    if (!prop.computed && prop.key.type === \"Identifier\") {\n      // PropertyDefinition:\n      //   IdentifierReference\n      //   CoverInitializedName\n      // Note: `{ eval } = {}` will be checked in `checkLVal` later.\n      this.checkReservedWord(prop.key.name, prop.key.loc.start, true, false);\n\n      if (isPattern) {\n        prop.value = this.parseMaybeDefault(\n          startLoc,\n          cloneIdentifier(prop.key),\n        );\n      } else if (this.match(tt.eq)) {\n        const shorthandAssignLoc = this.state.startLoc;\n        if (refExpressionErrors != null) {\n          if (refExpressionErrors.shorthandAssignLoc === null) {\n            refExpressionErrors.shorthandAssignLoc = shorthandAssignLoc;\n          }\n        } else {\n          this.raise(Errors.InvalidCoverInitializedName, {\n            at: shorthandAssignLoc,\n          });\n        }\n        prop.value = this.parseMaybeDefault(\n          startLoc,\n          cloneIdentifier(prop.key),\n        );\n      } else {\n        prop.value = cloneIdentifier(prop.key);\n      }\n      prop.shorthand = true;\n\n      return this.finishNode(prop, \"ObjectProperty\");\n    }\n  }\n\n  parseObjPropValue(\n    this: Parser,\n    prop: Undone<N.ObjectMethod | N.ObjectProperty>,\n    startLoc: Position | undefined | null,\n    isGenerator: boolean,\n    isAsync: boolean,\n    isPattern: boolean,\n    isAccessor: boolean,\n    refExpressionErrors?: ExpressionErrors | null,\n  ): N.ObjectMethod | N.ObjectProperty {\n    const node =\n      this.parseObjectMethod(\n        prop as Undone<N.ObjectMethod>,\n        isGenerator,\n        isAsync,\n        isPattern,\n        isAccessor,\n      ) ||\n      this.parseObjectProperty(\n        prop as Undone<N.ObjectProperty>,\n        startLoc,\n        isPattern,\n        refExpressionErrors,\n      );\n\n    if (!node) this.unexpected();\n\n    return node;\n  }\n\n  // https://tc39.es/ecma262/#prod-PropertyName\n  // when refExpressionErrors presents, it will parse private name\n  // and record the position of the first private name\n  parsePropertyName(\n    this: Parser,\n    prop:\n      | Undone<N.ObjectOrClassMember | N.ClassMember>\n      | N.TsNamedTypeElementBase,\n    refExpressionErrors?: ExpressionErrors | null,\n  ): N.Expression | N.Identifier {\n    if (this.eat(tt.bracketL)) {\n      (prop as Undone<N.ObjectOrClassMember>).computed = true;\n      prop.key = this.parseMaybeAssignAllowIn();\n      this.expect(tt.bracketR);\n    } else {\n      // We check if it's valid for it to be a private name when we push it.\n      const { type, value } = this.state;\n      let key;\n      // most un-computed property names are identifiers\n      if (tokenIsKeywordOrIdentifier(type)) {\n        key = this.parseIdentifier(true);\n      } else {\n        switch (type) {\n          case tt.num:\n            key = this.parseNumericLiteral(value);\n            break;\n          case tt.string:\n            key = this.parseStringLiteral(value);\n            break;\n          case tt.bigint:\n            key = this.parseBigIntLiteral(value);\n            break;\n          case tt.decimal:\n            key = this.parseDecimalLiteral(value);\n            break;\n          case tt.privateName: {\n            // the class private key has been handled in parseClassElementName\n            const privateKeyLoc = this.state.startLoc;\n            if (refExpressionErrors != null) {\n              if (refExpressionErrors.privateKeyLoc === null) {\n                refExpressionErrors.privateKeyLoc = privateKeyLoc;\n              }\n            } else {\n              this.raise(Errors.UnexpectedPrivateField, {\n                at: privateKeyLoc,\n              });\n            }\n            key = this.parsePrivateName();\n            break;\n          }\n          default:\n            this.unexpected();\n        }\n      }\n      (prop as any).key = key;\n      if (type !== tt.privateName) {\n        // ClassPrivateProperty is never computed, so we don't assign in that case.\n        prop.computed = false;\n      }\n    }\n\n    return prop.key;\n  }\n\n  // Initialize empty function node.\n\n  initFunction(node: N.BodilessFunctionOrMethodBase, isAsync: boolean): void {\n    node.id = null;\n    node.generator = false;\n    node.async = isAsync;\n  }\n\n  // Parse object or class method.\n\n  parseMethod<T extends N.ObjectMethod | N.ClassMethod | N.ClassPrivateMethod>(\n    this: Parser,\n    node: Undone<T>,\n    isGenerator: boolean,\n    isAsync: boolean,\n    isConstructor: boolean,\n    allowDirectSuper: boolean,\n    type: T[\"type\"],\n    inClassScope: boolean = false,\n  ): T {\n    this.initFunction(node, isAsync);\n    node.generator = isGenerator;\n    this.scope.enter(\n      SCOPE_FUNCTION |\n        SCOPE_SUPER |\n        (inClassScope ? SCOPE_CLASS : 0) |\n        (allowDirectSuper ? SCOPE_DIRECT_SUPER : 0),\n    );\n    this.prodParam.enter(functionFlags(isAsync, node.generator));\n    this.parseFunctionParams(node, isConstructor);\n    const finishedNode = this.parseFunctionBodyAndFinish(node, type, true);\n    this.prodParam.exit();\n    this.scope.exit();\n\n    return finishedNode;\n  }\n\n  // parse an array literal or tuple literal\n  // https://tc39.es/ecma262/#prod-ArrayLiteral\n  // https://tc39.es/proposal-record-tuple/#prod-TupleLiteral\n  parseArrayLike(\n    this: Parser,\n    close: TokenType,\n    canBePattern: boolean,\n    isTuple: boolean,\n    refExpressionErrors?: ExpressionErrors | null,\n  ): N.ArrayExpression | N.TupleExpression {\n    if (isTuple) {\n      this.expectPlugin(\"recordAndTuple\");\n    }\n    const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;\n    this.state.inFSharpPipelineDirectBody = false;\n    const node = this.startNode<N.ArrayExpression | N.TupleExpression>();\n    this.next();\n    node.elements = this.parseExprList(\n      close,\n      /* allowEmpty */ !isTuple,\n      refExpressionErrors,\n      // @ts-expect-error todo(flow->ts)\n      node,\n    );\n    this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;\n    return this.finishNode(\n      node,\n      isTuple ? \"TupleExpression\" : \"ArrayExpression\",\n    );\n  }\n\n  // Parse arrow function expression.\n  // If the parameters are provided, they will be converted to an\n  // assignable list.\n  parseArrowExpression(\n    this: Parser,\n    node: Undone<N.ArrowFunctionExpression>,\n    params: N.Expression[] | undefined | null,\n    isAsync: boolean,\n    trailingCommaLoc?: Position | null,\n  ): N.ArrowFunctionExpression {\n    this.scope.enter(SCOPE_FUNCTION | SCOPE_ARROW);\n    let flags = functionFlags(isAsync, false);\n    // ConciseBody[In] :\n    //   [lookahead ≠ {] ExpressionBody[?In, ~Await]\n    //   { FunctionBody[~Yield, ~Await] }\n    if (!this.match(tt.braceL) && this.prodParam.hasIn) {\n      flags |= PARAM_IN;\n    }\n    this.prodParam.enter(flags);\n    this.initFunction(node, isAsync);\n    const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;\n\n    if (params) {\n      this.state.maybeInArrowParameters = true;\n      this.setArrowFunctionParameters(node, params, trailingCommaLoc);\n    }\n    this.state.maybeInArrowParameters = false;\n    this.parseFunctionBody(node, true);\n\n    this.prodParam.exit();\n    this.scope.exit();\n    this.state.maybeInArrowParameters = oldMaybeInArrowParameters;\n\n    return this.finishNode(node, \"ArrowFunctionExpression\");\n  }\n\n  setArrowFunctionParameters(\n    node: Undone<N.ArrowFunctionExpression>,\n    params: N.Expression[],\n    trailingCommaLoc?: Position | null,\n  ): void {\n    this.toAssignableList(params, trailingCommaLoc, false);\n    node.params = params as (N.Pattern | N.TSParameterProperty)[];\n  }\n\n  parseFunctionBodyAndFinish<\n    T extends\n      | N.Function\n      | N.TSDeclareMethod\n      | N.TSDeclareFunction\n      | N.ClassPrivateMethod,\n  >(node: Undone<T>, type: T[\"type\"], isMethod: boolean = false): T {\n    // @ts-expect-error (node is not bodiless if we get here)\n    this.parseFunctionBody(node, false, isMethod);\n    return this.finishNode(node, type);\n  }\n\n  // Parse function body and check parameters.\n  parseFunctionBody(\n    this: Parser,\n    node: Undone<N.Function>,\n    allowExpression?: boolean | null,\n    isMethod: boolean = false,\n  ): void {\n    const isExpression = allowExpression && !this.match(tt.braceL);\n    this.expressionScope.enter(newExpressionScope());\n\n    if (isExpression) {\n      // https://tc39.es/ecma262/#prod-ExpressionBody\n      (node as Undone<N.ArrowFunctionExpression>).body =\n        this.parseMaybeAssign();\n      this.checkParams(node, false, allowExpression, false);\n    } else {\n      const oldStrict = this.state.strict;\n      // Start a new scope with regard to labels\n      // flag (restore them to their old value afterwards).\n      const oldLabels = this.state.labels;\n      this.state.labels = [];\n\n      // FunctionBody[Yield, Await]:\n      //   StatementList[?Yield, ?Await, +Return] opt\n      this.prodParam.enter(this.prodParam.currentFlags() | PARAM_RETURN);\n      node.body = this.parseBlock(\n        true,\n        false,\n        // Strict mode function checks after we parse the statements in the function body.\n        (hasStrictModeDirective: boolean) => {\n          const nonSimple = !this.isSimpleParamList(node.params);\n\n          if (hasStrictModeDirective && nonSimple) {\n            // This logic is here to align the error location with the ESTree plugin.\n            this.raise(Errors.IllegalLanguageModeDirective, {\n              at:\n                // @ts-expect-error kind may not index node\n                (node.kind === \"method\" || node.kind === \"constructor\") &&\n                // @ts-expect-error key may not index node\n                !!node.key\n                  ? // @ts-expect-error node.key has been guarded\n                    node.key.loc.end\n                  : node,\n            });\n          }\n\n          const strictModeChanged = !oldStrict && this.state.strict;\n\n          // Add the params to varDeclaredNames to ensure that an error is thrown\n          // if a let/const declaration in the function clashes with one of the params.\n          this.checkParams(\n            node,\n            !this.state.strict && !allowExpression && !isMethod && !nonSimple,\n            allowExpression,\n            strictModeChanged,\n          );\n\n          // Ensure the function name isn't a forbidden identifier in strict mode, e.g. 'eval'\n          if (this.state.strict && node.id) {\n            this.checkIdentifier(node.id, BIND_OUTSIDE, strictModeChanged);\n          }\n        },\n      );\n      this.prodParam.exit();\n      this.state.labels = oldLabels;\n    }\n    this.expressionScope.exit();\n  }\n\n  isSimpleParameter(node: N.Pattern | N.TSParameterProperty) {\n    return node.type === \"Identifier\";\n  }\n\n  isSimpleParamList(\n    params: ReadonlyArray<N.Pattern | N.TSParameterProperty>,\n  ): boolean {\n    for (let i = 0, len = params.length; i < len; i++) {\n      if (!this.isSimpleParameter(params[i])) return false;\n    }\n    return true;\n  }\n\n  checkParams(\n    node: Undone<N.Function>,\n    allowDuplicates: boolean,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    isArrowFunction?: boolean | null,\n    strictModeChanged: boolean = true,\n  ): void {\n    const checkClashes = !allowDuplicates && new Set<string>();\n    // We create a fake node with the \"ephemeral\" type `FormalParameters`[1]\n    // since we just store an array of parameters. Perhaps someday we can have\n    // something like class FormalParameters extends Array { ... }, which would\n    // also be helpful when traversing this node.\n    //\n    // 1. https://tc39.es/ecma262/#prod-FormalParameters\n    const formalParameters = { type: \"FormalParameters\" } as const;\n    for (const param of node.params) {\n      this.checkLVal(param, {\n        in: formalParameters,\n        binding: BIND_VAR,\n        checkClashes,\n        strictModeChanged,\n      });\n    }\n  }\n\n  // Parses a comma-separated list of expressions, and returns them as\n  // an array. `close` is the token type that ends the list, and\n  // `allowEmpty` can be turned on to allow subsequent commas with\n  // nothing in between them to be parsed as `null` (which is needed\n  // for array literals).\n\n  parseExprList(\n    this: Parser,\n    close: TokenType,\n    allowEmpty?: boolean,\n    refExpressionErrors?: ExpressionErrors | null,\n    nodeForExtra?: N.Node | null,\n  ): (N.Expression | null)[] {\n    const elts: (N.Expression | null)[] = [];\n    let first = true;\n\n    while (!this.eat(close)) {\n      if (first) {\n        first = false;\n      } else {\n        this.expect(tt.comma);\n        if (this.match(close)) {\n          if (nodeForExtra) {\n            this.addTrailingCommaExtraToNode(nodeForExtra);\n          }\n          this.next();\n          break;\n        }\n      }\n\n      elts.push(this.parseExprListItem(allowEmpty, refExpressionErrors));\n    }\n    return elts;\n  }\n\n  parseExprListItem(\n    this: Parser,\n    allowEmpty?: boolean,\n    refExpressionErrors?: ExpressionErrors | null,\n    allowPlaceholder?: boolean | null,\n  ): N.Expression | null;\n  parseExprListItem(\n    this: Parser,\n    allowEmpty?: false,\n    refExpressionErrors?: ExpressionErrors | null,\n    allowPlaceholder?: boolean | null,\n  ): N.Expression;\n  parseExprListItem(\n    this: Parser,\n    allowEmpty?: boolean | null,\n    refExpressionErrors?: ExpressionErrors | null,\n    allowPlaceholder?: boolean | null,\n  ): N.Expression | null {\n    let elt;\n    if (this.match(tt.comma)) {\n      if (!allowEmpty) {\n        this.raise(Errors.UnexpectedToken, {\n          at: this.state.curPosition(),\n          unexpected: \",\",\n        });\n      }\n      elt = null;\n    } else if (this.match(tt.ellipsis)) {\n      const spreadNodeStartLoc = this.state.startLoc;\n\n      elt = this.parseParenItem(\n        this.parseSpread(refExpressionErrors),\n        spreadNodeStartLoc,\n      );\n    } else if (this.match(tt.question)) {\n      this.expectPlugin(\"partialApplication\");\n      if (!allowPlaceholder) {\n        this.raise(Errors.UnexpectedArgumentPlaceholder, {\n          at: this.state.startLoc,\n        });\n      }\n      const node = this.startNode();\n      this.next();\n      elt = this.finishNode(node, \"ArgumentPlaceholder\");\n    } else {\n      elt = this.parseMaybeAssignAllowIn(\n        refExpressionErrors,\n        this.parseParenItem,\n      );\n    }\n    return elt;\n  }\n\n  // Parse the next token as an identifier. If `liberal` is true (used\n  // when parsing properties), it will also convert keywords into\n  // identifiers.\n  // This shouldn't be used to parse the keywords of meta properties, since they\n  // are not identifiers and cannot contain escape sequences.\n\n  parseIdentifier(liberal?: boolean): N.Identifier {\n    const node = this.startNode<N.Identifier>();\n    const name = this.parseIdentifierName(liberal);\n\n    return this.createIdentifier(node, name);\n  }\n\n  createIdentifier(\n    node: Omit<N.Identifier, \"type\">,\n    name: string,\n  ): N.Identifier {\n    node.name = name;\n    node.loc.identifierName = name;\n\n    return this.finishNode(node, \"Identifier\");\n  }\n\n  parseIdentifierName(liberal?: boolean): string {\n    let name: string;\n\n    const { startLoc, type } = this.state;\n\n    if (tokenIsKeywordOrIdentifier(type)) {\n      name = this.state.value;\n    } else {\n      this.unexpected();\n    }\n\n    const tokenIsKeyword = tokenKeywordOrIdentifierIsKeyword(type);\n\n    if (liberal) {\n      // If the current token is not used as a keyword, set its type to \"tt.name\".\n      // This will prevent this.next() from throwing about unexpected escapes.\n      if (tokenIsKeyword) {\n        this.replaceToken(tt.name);\n      }\n    } else {\n      this.checkReservedWord(name, startLoc, tokenIsKeyword, false);\n    }\n\n    this.next();\n\n    return name;\n  }\n\n  checkReservedWord(\n    word: string,\n    startLoc: Position,\n    checkKeywords: boolean,\n    isBinding: boolean,\n  ): void {\n    // Every JavaScript reserved word is 10 characters or less.\n    if (word.length > 10) {\n      return;\n    }\n    // Most identifiers are not reservedWord-like, they don't need special\n    // treatments afterward, which very likely ends up throwing errors\n    if (!canBeReservedWord(word)) {\n      return;\n    }\n\n    if (checkKeywords && isKeyword(word)) {\n      this.raise(Errors.UnexpectedKeyword, {\n        at: startLoc,\n        keyword: word,\n      });\n      return;\n    }\n\n    const reservedTest = !this.state.strict\n      ? isReservedWord\n      : isBinding\n      ? isStrictBindReservedWord\n      : isStrictReservedWord;\n\n    if (reservedTest(word, this.inModule)) {\n      this.raise(Errors.UnexpectedReservedWord, {\n        at: startLoc,\n        reservedWord: word,\n      });\n      return;\n    } else if (word === \"yield\") {\n      if (this.prodParam.hasYield) {\n        this.raise(Errors.YieldBindingIdentifier, { at: startLoc });\n        return;\n      }\n    } else if (word === \"await\") {\n      if (this.prodParam.hasAwait) {\n        this.raise(Errors.AwaitBindingIdentifier, { at: startLoc });\n        return;\n      }\n\n      if (this.scope.inStaticBlock) {\n        this.raise(Errors.AwaitBindingIdentifierInStaticBlock, {\n          at: startLoc,\n        });\n        return;\n      }\n\n      this.expressionScope.recordAsyncArrowParametersError({ at: startLoc });\n    } else if (word === \"arguments\") {\n      if (this.scope.inClassAndNotInNonArrowFunction) {\n        this.raise(Errors.ArgumentsInClass, { at: startLoc });\n        return;\n      }\n    }\n  }\n\n  isAwaitAllowed(): boolean {\n    if (this.prodParam.hasAwait) return true;\n    if (this.options.allowAwaitOutsideFunction && !this.scope.inFunction) {\n      return true;\n    }\n    return false;\n  }\n\n  // Parses await expression inside async function.\n\n  parseAwait(this: Parser, startLoc: Position): N.AwaitExpression {\n    const node = this.startNodeAt<N.AwaitExpression>(startLoc);\n\n    this.expressionScope.recordParameterInitializerError(\n      Errors.AwaitExpressionFormalParameter,\n      {\n        // @ts-expect-error todo(flow->ts)\n        at: node,\n      },\n    );\n\n    if (this.eat(tt.star)) {\n      this.raise(Errors.ObsoleteAwaitStar, { at: node });\n    }\n\n    if (!this.scope.inFunction && !this.options.allowAwaitOutsideFunction) {\n      if (this.isAmbiguousAwait()) {\n        this.ambiguousScriptDifferentAst = true;\n      } else {\n        this.sawUnambiguousESM = true;\n      }\n    }\n\n    if (!this.state.soloAwait) {\n      node.argument = this.parseMaybeUnary(null, true);\n    }\n\n    return this.finishNode(node, \"AwaitExpression\");\n  }\n\n  isAmbiguousAwait(): boolean {\n    if (this.hasPrecedingLineBreak()) return true;\n    const { type } = this.state;\n    return (\n      // All the following expressions are ambiguous:\n      //   await + 0, await - 0, await ( 0 ), await [ 0 ], await / 0 /u, await ``, await of []\n      type === tt.plusMin ||\n      type === tt.parenL ||\n      type === tt.bracketL ||\n      tokenIsTemplate(type) ||\n      (type === tt._of && !this.state.containsEsc) ||\n      // Sometimes the tokenizer generates tt.slash for regexps, and this is\n      // handler by parseExprAtom\n      type === tt.regexp ||\n      type === tt.slash ||\n      // This code could be parsed both as a modulo operator or as an intrinsic:\n      //   await %x(0)\n      (this.hasPlugin(\"v8intrinsic\") && type === tt.modulo)\n    );\n  }\n\n  // Parses yield expression inside generator.\n\n  parseYield(this: Parser): N.YieldExpression {\n    const node = this.startNode<N.YieldExpression>();\n\n    this.expressionScope.recordParameterInitializerError(\n      Errors.YieldInParameter,\n      {\n        // @ts-expect-error todo(flow->ts)\n        at: node,\n      },\n    );\n\n    this.next();\n    let delegating = false;\n    let argument: N.Expression | null = null;\n    if (!this.hasPrecedingLineBreak()) {\n      delegating = this.eat(tt.star);\n      switch (this.state.type) {\n        case tt.semi:\n        case tt.eof:\n        case tt.braceR:\n        case tt.parenR:\n        case tt.bracketR:\n        case tt.braceBarR:\n        case tt.colon:\n        case tt.comma:\n          // The above is the complete set of tokens that can\n          // follow an AssignmentExpression, and none of them\n          // can start an AssignmentExpression\n          if (!delegating) break;\n        /* fallthrough */\n        default:\n          argument = this.parseMaybeAssign();\n      }\n    }\n    node.delegate = delegating;\n    node.argument = argument;\n    return this.finishNode(node, \"YieldExpression\");\n  }\n\n  // Validates a pipeline (for any of the pipeline Babylon plugins) at the point\n  // of the infix operator `|>`.\n\n  checkPipelineAtInfixOperator(left: N.Expression, leftStartLoc: Position) {\n    if (this.hasPlugin([\"pipelineOperator\", { proposal: \"smart\" }])) {\n      if (left.type === \"SequenceExpression\") {\n        // Ensure that the pipeline head is not a comma-delimited\n        // sequence expression.\n        this.raise(Errors.PipelineHeadSequenceExpression, {\n          at: leftStartLoc,\n        });\n      }\n    }\n  }\n\n  parseSmartPipelineBodyInStyle(childExpr: N.Expression, startLoc: Position) {\n    if (this.isSimpleReference(childExpr)) {\n      const bodyNode = this.startNodeAt<N.PipelineBareFunction>(startLoc);\n      bodyNode.callee = childExpr;\n      return this.finishNode(bodyNode, \"PipelineBareFunction\");\n    } else {\n      const bodyNode = this.startNodeAt<N.PipelineTopicExpression>(startLoc);\n      this.checkSmartPipeTopicBodyEarlyErrors(startLoc);\n      bodyNode.expression = childExpr;\n      return this.finishNode(bodyNode, \"PipelineTopicExpression\");\n    }\n  }\n\n  isSimpleReference(expression: N.Expression): boolean {\n    switch (expression.type) {\n      case \"MemberExpression\":\n        return (\n          !expression.computed && this.isSimpleReference(expression.object)\n        );\n      case \"Identifier\":\n        return true;\n      default:\n        return false;\n    }\n  }\n\n  // This helper method is to be called immediately\n  // after a topic-style smart-mix pipe body is parsed.\n  // The `startLoc` is the starting position of the pipe body.\n\n  checkSmartPipeTopicBodyEarlyErrors(startLoc: Position): void {\n    // If the following token is invalidly `=>`, then throw a human-friendly error\n    // instead of something like 'Unexpected token, expected \";\"'.\n    // For example, `x => x |> y => #` (assuming `#` is the topic reference)\n    // groups into `x => (x |> y) => #`,\n    // and `(x |> y) => #` is an invalid arrow function.\n    // This is because smart-mix `|>` has tighter precedence than `=>`.\n    if (this.match(tt.arrow)) {\n      throw this.raise(Errors.PipelineBodyNoArrow, { at: this.state.startLoc });\n    }\n\n    // A topic-style smart-mix pipe body must use the topic reference at least once.\n    if (!this.topicReferenceWasUsedInCurrentContext()) {\n      this.raise(Errors.PipelineTopicUnused, { at: startLoc });\n    }\n  }\n\n  // Enable topic references from outer contexts within Hack-style pipe bodies.\n  // The function modifies the parser's topic-context state to enable or disable\n  // the use of topic references.\n  // The function then calls a callback, then resets the parser\n  // to the old topic-context state that it had before the function was called.\n\n  withTopicBindingContext<T>(callback: () => T): T {\n    const outerContextTopicState = this.state.topicContext;\n    this.state.topicContext = {\n      // Enable the use of the primary topic reference.\n      maxNumOfResolvableTopics: 1,\n      // Hide the use of any topic references from outer contexts.\n      maxTopicIndex: null,\n    };\n\n    try {\n      return callback();\n    } finally {\n      this.state.topicContext = outerContextTopicState;\n    }\n  }\n\n  // This helper method is used only with the deprecated smart-mix pipe proposal.\n  // Disables topic references from outer contexts within syntax constructs\n  // such as the bodies of iteration statements.\n  // The function modifies the parser's topic-context state to enable or disable\n  // the use of topic references with the smartPipelines plugin. They then run a\n  // callback, then they reset the parser to the old topic-context state that it\n  // had before the function was called.\n\n  withSmartMixTopicForbiddingContext<T>(callback: () => T): T {\n    if (this.hasPlugin([\"pipelineOperator\", { proposal: \"smart\" }])) {\n      // Reset the parser’s topic context only if the smart-mix pipe proposal is active.\n      const outerContextTopicState = this.state.topicContext;\n      this.state.topicContext = {\n        // Disable the use of the primary topic reference.\n        maxNumOfResolvableTopics: 0,\n        // Hide the use of any topic references from outer contexts.\n        maxTopicIndex: null,\n      };\n\n      try {\n        return callback();\n      } finally {\n        this.state.topicContext = outerContextTopicState;\n      }\n    } else {\n      // If the pipe proposal is \"minimal\", \"fsharp\", or \"hack\",\n      // or if no pipe proposal is active,\n      // then the callback result is returned\n      // without touching any extra parser state.\n      return callback();\n    }\n  }\n\n  withSoloAwaitPermittingContext<T>(callback: () => T): T {\n    const outerContextSoloAwaitState = this.state.soloAwait;\n    this.state.soloAwait = true;\n\n    try {\n      return callback();\n    } finally {\n      this.state.soloAwait = outerContextSoloAwaitState;\n    }\n  }\n\n  allowInAnd<T>(callback: () => T): T {\n    const flags = this.prodParam.currentFlags();\n    const prodParamToSet = PARAM_IN & ~flags;\n    if (prodParamToSet) {\n      this.prodParam.enter(flags | PARAM_IN);\n      try {\n        return callback();\n      } finally {\n        this.prodParam.exit();\n      }\n    }\n    return callback();\n  }\n\n  disallowInAnd<T>(callback: () => T): T {\n    const flags = this.prodParam.currentFlags();\n    const prodParamToClear = PARAM_IN & flags;\n    if (prodParamToClear) {\n      this.prodParam.enter(flags & ~PARAM_IN);\n      try {\n        return callback();\n      } finally {\n        this.prodParam.exit();\n      }\n    }\n    return callback();\n  }\n\n  // Register the use of a topic reference within the current\n  // topic-binding context.\n  registerTopicReference(): void {\n    this.state.topicContext.maxTopicIndex = 0;\n  }\n\n  topicReferenceIsAllowedInCurrentContext(): boolean {\n    return this.state.topicContext.maxNumOfResolvableTopics >= 1;\n  }\n\n  topicReferenceWasUsedInCurrentContext(): boolean {\n    return (\n      this.state.topicContext.maxTopicIndex != null &&\n      this.state.topicContext.maxTopicIndex >= 0\n    );\n  }\n\n  parseFSharpPipelineBody(this: Parser, prec: number): N.Expression {\n    const startLoc = this.state.startLoc;\n\n    this.state.potentialArrowAt = this.state.start;\n    const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;\n    this.state.inFSharpPipelineDirectBody = true;\n\n    const ret = this.parseExprOp(\n      this.parseMaybeUnaryOrPrivate(),\n      startLoc,\n      prec,\n    );\n\n    this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;\n\n    return ret;\n  }\n\n  // https://github.com/tc39/proposal-js-module-blocks\n  parseModuleExpression(this: Parser): N.ModuleExpression {\n    this.expectPlugin(\"moduleBlocks\");\n    const node = this.startNode<N.ModuleExpression>();\n    this.next(); // eat \"module\"\n    if (!this.match(tt.braceL)) {\n      this.unexpected(null, tt.braceL);\n    }\n    // start program node immediately after `{`\n    const program = this.startNodeAt<N.Program>(this.state.endLoc);\n    this.next(); // eat `{`\n\n    const revertScopes = this.initializeScopes(/** inModule */ true);\n    this.enterInitialScopes();\n\n    try {\n      node.body = this.parseProgram(program, tt.braceR, \"module\");\n    } finally {\n      revertScopes();\n    }\n    return this.finishNode<N.ModuleExpression>(node, \"ModuleExpression\");\n  }\n\n  // Used in Flow plugin\n  parsePropertyNamePrefixOperator(\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    prop: Undone<N.ObjectOrClassMember | N.ClassMember>,\n  ): void {}\n}\n","import type * as N from \"../types\";\nimport {\n  tokenIsIdentifier,\n  tokenIsKeywordOrIdentifier,\n  tokenIsLoop,\n  tokenIsTemplate,\n  tt,\n  type TokenType,\n  getExportedToken,\n} from \"../tokenizer/types\";\nimport ExpressionParser from \"./expression\";\nimport { Errors } from \"../parse-error\";\nimport { isIdentifierChar, isIdentifierStart } from \"../util/identifier\";\nimport * as charCodes from \"charcodes\";\nimport {\n  BIND_CLASS,\n  BIND_LEXICAL,\n  BIND_VAR,\n  BIND_FUNCTION,\n  SCOPE_CLASS,\n  SCOPE_FUNCTION,\n  SCOPE_OTHER,\n  SCOPE_SIMPLE_CATCH,\n  SCOPE_STATIC_BLOCK,\n  SCOPE_SUPER,\n  CLASS_ELEMENT_OTHER,\n  CLASS_ELEMENT_INSTANCE_GETTER,\n  CLASS_ELEMENT_INSTANCE_SETTER,\n  CLASS_ELEMENT_STATIC_GETTER,\n  CLASS_ELEMENT_STATIC_SETTER,\n  type BindingTypes,\n  BIND_CATCH_PARAM,\n} from \"../util/scopeflags\";\nimport { ExpressionErrors } from \"./util\";\nimport { PARAM, functionFlags } from \"../util/production-parameter\";\nimport {\n  newExpressionScope,\n  newParameterDeclarationScope,\n} from \"../util/expression-scope\";\nimport type { SourceType } from \"../options\";\nimport { Token } from \"../tokenizer\";\nimport type { Position } from \"../util/location\";\nimport { createPositionWithColumnOffset } from \"../util/location\";\nimport { cloneStringLiteral, cloneIdentifier, type Undone } from \"./node\";\nimport type Parser from \"./index\";\nimport { ParseBindingListFlags } from \"./lval\";\n\nconst loopLabel = { kind: \"loop\" } as const,\n  switchLabel = { kind: \"switch\" } as const;\n\nexport const enum ParseFunctionFlag {\n  Expression = 0b0000,\n  Declaration = 0b0001,\n  HangingDeclaration = 0b0010,\n  NullableId = 0b0100,\n  Async = 0b1000,\n}\n\nexport const enum ParseStatementFlag {\n  StatementOnly = 0b0000,\n  AllowImportExport = 0b0001,\n  AllowDeclaration = 0b0010,\n  AllowFunctionDeclaration = 0b0100,\n  AllowLabeledFunction = 0b1000,\n}\n\nconst loneSurrogate = /[\\uD800-\\uDFFF]/u;\n\nconst keywordRelationalOperator = /in(?:stanceof)?/y;\n\n/**\n * Convert tokens for backward Babel 7 compat.\n * tt.privateName => tt.hash + tt.name\n * tt.templateTail => tt.backquote/tt.braceR + tt.template + tt.backquote\n * tt.templateNonTail => tt.backquote/tt.braceR + tt.template + tt.dollarBraceL\n * For performance reasons this routine mutates `tokens`, it is okay\n * here since we execute `parseTopLevel` once for every file.\n */\nfunction babel7CompatTokens(tokens: (Token | N.Comment)[], input: string) {\n  for (let i = 0; i < tokens.length; i++) {\n    const token = tokens[i];\n    const { type } = token;\n    if (typeof type === \"number\") {\n      if (!process.env.BABEL_8_BREAKING) {\n        if (type === tt.privateName) {\n          const { loc, start, value, end } = token;\n          const hashEndPos = start + 1;\n          const hashEndLoc = createPositionWithColumnOffset(loc.start, 1);\n          tokens.splice(\n            i,\n            1,\n            new Token({\n              // @ts-expect-error: hacky way to create token\n              type: getExportedToken(tt.hash),\n              value: \"#\",\n              start: start,\n              end: hashEndPos,\n              startLoc: loc.start,\n              endLoc: hashEndLoc,\n            }),\n            new Token({\n              // @ts-expect-error: hacky way to create token\n              type: getExportedToken(tt.name),\n              value: value,\n              start: hashEndPos,\n              end: end,\n              startLoc: hashEndLoc,\n              endLoc: loc.end,\n            }),\n          );\n          i++;\n          continue;\n        }\n\n        if (tokenIsTemplate(type)) {\n          const { loc, start, value, end } = token;\n          const backquoteEnd = start + 1;\n          const backquoteEndLoc = createPositionWithColumnOffset(loc.start, 1);\n          let startToken;\n          if (input.charCodeAt(start) === charCodes.graveAccent) {\n            startToken = new Token({\n              // @ts-expect-error: hacky way to create token\n              type: getExportedToken(tt.backQuote),\n              value: \"`\",\n              start: start,\n              end: backquoteEnd,\n              startLoc: loc.start,\n              endLoc: backquoteEndLoc,\n            });\n          } else {\n            startToken = new Token({\n              // @ts-expect-error: hacky way to create token\n              type: getExportedToken(tt.braceR),\n              value: \"}\",\n              start: start,\n              end: backquoteEnd,\n              startLoc: loc.start,\n              endLoc: backquoteEndLoc,\n            });\n          }\n          let templateValue,\n            templateElementEnd,\n            templateElementEndLoc,\n            endToken;\n          if (type === tt.templateTail) {\n            // ends with '`'\n            templateElementEnd = end - 1;\n            templateElementEndLoc = createPositionWithColumnOffset(loc.end, -1);\n            templateValue = value === null ? null : value.slice(1, -1);\n            endToken = new Token({\n              // @ts-expect-error: hacky way to create token\n              type: getExportedToken(tt.backQuote),\n              value: \"`\",\n              start: templateElementEnd,\n              end: end,\n              startLoc: templateElementEndLoc,\n              endLoc: loc.end,\n            });\n          } else {\n            // ends with `${`\n            templateElementEnd = end - 2;\n            templateElementEndLoc = createPositionWithColumnOffset(loc.end, -2);\n            templateValue = value === null ? null : value.slice(1, -2);\n            endToken = new Token({\n              // @ts-expect-error: hacky way to create token\n              type: getExportedToken(tt.dollarBraceL),\n              value: \"${\",\n              start: templateElementEnd,\n              end: end,\n              startLoc: templateElementEndLoc,\n              endLoc: loc.end,\n            });\n          }\n          tokens.splice(\n            i,\n            1,\n            startToken,\n            new Token({\n              // @ts-expect-error: hacky way to create token\n              type: getExportedToken(tt.template),\n              value: templateValue,\n              start: backquoteEnd,\n              end: templateElementEnd,\n              startLoc: backquoteEndLoc,\n              endLoc: templateElementEndLoc,\n            }),\n            endToken,\n          );\n          i += 2;\n          continue;\n        }\n      }\n      // @ts-expect-error: we manipulate `token` for performance reasons\n      token.type = getExportedToken(type);\n    }\n  }\n  return tokens;\n}\nexport default abstract class StatementParser extends ExpressionParser {\n  // ### Statement parsing\n\n  // Parse a program. Initializes the parser, reads any number of\n  // statements, and wraps them in a Program node.  Optionally takes a\n  // `program` argument.  If present, the statements will be appended\n  // to its body instead of creating a new node.\n\n  parseTopLevel(this: Parser, file: N.File, program: N.Program): N.File {\n    file.program = this.parseProgram(program);\n    file.comments = this.state.comments;\n\n    if (this.options.tokens) {\n      file.tokens = babel7CompatTokens(this.tokens, this.input);\n    }\n\n    return this.finishNode(file, \"File\");\n  }\n\n  parseProgram(\n    this: Parser,\n    program: Undone<N.Program>,\n    end: TokenType = tt.eof,\n    sourceType: SourceType = this.options.sourceType,\n  ): N.Program {\n    program.sourceType = sourceType;\n    program.interpreter = this.parseInterpreterDirective();\n    this.parseBlockBody(program, true, true, end);\n    if (\n      this.inModule &&\n      !this.options.allowUndeclaredExports &&\n      this.scope.undefinedExports.size > 0\n    ) {\n      for (const [localName, at] of Array.from(this.scope.undefinedExports)) {\n        this.raise(Errors.ModuleExportUndefined, { at, localName });\n      }\n    }\n    let finishedProgram: N.Program;\n    if (end === tt.eof) {\n      // finish at eof for top level program\n      finishedProgram = this.finishNode(program, \"Program\");\n    } else {\n      // finish immediately before the end token\n      finishedProgram = this.finishNodeAt(\n        program,\n        \"Program\",\n        createPositionWithColumnOffset(this.state.startLoc, -1),\n      );\n    }\n    return finishedProgram;\n  }\n\n  /**\n   * cast a Statement to a Directive. This method mutates input statement.\n   */\n  stmtToDirective(stmt: N.Statement): N.Directive {\n    const directive = stmt as any;\n    directive.type = \"Directive\";\n    directive.value = directive.expression;\n    delete directive.expression;\n\n    const directiveLiteral = directive.value;\n    const expressionValue = directiveLiteral.value;\n    const raw = this.input.slice(directiveLiteral.start, directiveLiteral.end);\n    const val = (directiveLiteral.value = raw.slice(1, -1)); // remove quotes\n\n    this.addExtra(directiveLiteral, \"raw\", raw);\n    this.addExtra(directiveLiteral, \"rawValue\", val);\n    this.addExtra(directiveLiteral, \"expressionValue\", expressionValue);\n\n    directiveLiteral.type = \"DirectiveLiteral\";\n\n    return directive;\n  }\n\n  parseInterpreterDirective(): N.InterpreterDirective | null {\n    if (!this.match(tt.interpreterDirective)) {\n      return null;\n    }\n\n    const node = this.startNode<N.InterpreterDirective>();\n    node.value = this.state.value;\n    this.next();\n    return this.finishNode(node, \"InterpreterDirective\");\n  }\n\n  isLet(): boolean {\n    if (!this.isContextual(tt._let)) {\n      return false;\n    }\n    return this.hasFollowingBindingAtom();\n  }\n\n  chStartsBindingIdentifier(ch: number, pos: number) {\n    if (isIdentifierStart(ch)) {\n      keywordRelationalOperator.lastIndex = pos;\n      if (keywordRelationalOperator.test(this.input)) {\n        // We have seen `in` or `instanceof` so far, now check if the identifier\n        // ends here\n        const endCh = this.codePointAtPos(keywordRelationalOperator.lastIndex);\n        if (!isIdentifierChar(endCh) && endCh !== charCodes.backslash) {\n          return false;\n        }\n      }\n      return true;\n    } else if (ch === charCodes.backslash) {\n      return true;\n    } else {\n      return false;\n    }\n  }\n\n  chStartsBindingPattern(ch: number) {\n    return (\n      ch === charCodes.leftSquareBracket || ch === charCodes.leftCurlyBrace\n    );\n  }\n\n  /**\n   * Assuming we have seen a contextual `let` and declaration is allowed, check if it\n   * starts a variable declaration so that it should be interpreted as a keyword.\n   */\n  hasFollowingBindingAtom(): boolean {\n    const next = this.nextTokenStart();\n    const nextCh = this.codePointAtPos(next);\n    return (\n      this.chStartsBindingPattern(nextCh) ||\n      this.chStartsBindingIdentifier(nextCh, next)\n    );\n  }\n\n  /**\n   * Assuming we have seen a contextual `using` and declaration is allowed, check if it\n   * starts a variable declaration in the same line so that it should be interpreted as\n   * a keyword.\n   */\n  hasInLineFollowingBindingIdentifier(): boolean {\n    const next = this.nextTokenInLineStart();\n    const nextCh = this.codePointAtPos(next);\n    return this.chStartsBindingIdentifier(nextCh, next);\n  }\n\n  startsUsingForOf(): boolean {\n    const { type, containsEsc } = this.lookahead();\n    if (type === tt._of && !containsEsc) {\n      // `using of` must start a for-lhs-of statement\n      return false;\n    } else if (tokenIsIdentifier(type) && !this.hasFollowingLineBreak()) {\n      this.expectPlugin(\"explicitResourceManagement\");\n      return true;\n    }\n  }\n\n  startsAwaitUsing(): boolean {\n    let next = this.nextTokenInLineStart();\n    if (this.isUnparsedContextual(next, \"using\")) {\n      next = this.nextTokenInLineStartSince(next + 5);\n      const nextCh = this.codePointAtPos(next);\n      if (this.chStartsBindingIdentifier(nextCh, next)) {\n        this.expectPlugin(\"explicitResourceManagement\");\n        return true;\n      }\n    }\n    return false;\n  }\n\n  // https://tc39.es/ecma262/#prod-ModuleItem\n  parseModuleItem(this: Parser) {\n    return this.parseStatementLike(\n      ParseStatementFlag.AllowImportExport |\n        ParseStatementFlag.AllowDeclaration |\n        ParseStatementFlag.AllowFunctionDeclaration |\n        // This function is actually also used to parse StatementItems,\n        // which with Annex B enabled allows labeled functions.\n        ParseStatementFlag.AllowLabeledFunction,\n    );\n  }\n\n  // https://tc39.es/ecma262/#prod-StatementListItem\n  parseStatementListItem(this: Parser) {\n    return this.parseStatementLike(\n      ParseStatementFlag.AllowDeclaration |\n        ParseStatementFlag.AllowFunctionDeclaration |\n        (!this.options.annexB || this.state.strict\n          ? 0\n          : ParseStatementFlag.AllowLabeledFunction),\n    );\n  }\n\n  parseStatementOrSloppyAnnexBFunctionDeclaration(\n    this: Parser,\n    allowLabeledFunction: boolean = false,\n  ) {\n    let flags: ParseStatementFlag = ParseStatementFlag.StatementOnly;\n    if (this.options.annexB && !this.state.strict) {\n      flags |= ParseStatementFlag.AllowFunctionDeclaration;\n      if (allowLabeledFunction) {\n        flags |= ParseStatementFlag.AllowLabeledFunction;\n      }\n    }\n    return this.parseStatementLike(flags);\n  }\n\n  // Parse a single statement.\n  //\n  // If expecting a statement and finding a slash operator, parse a\n  // regular expression literal. This is to handle cases like\n  // `if (foo) /blah/.exec(foo)`, where looking at the previous token\n  // does not help.\n  // https://tc39.es/ecma262/#prod-Statement\n  parseStatement(this: Parser) {\n    return this.parseStatementLike(ParseStatementFlag.StatementOnly);\n  }\n\n  // ImportDeclaration and ExportDeclaration are also handled here so we can throw recoverable errors\n  // when they are not at the top level\n  parseStatementLike(\n    this: Parser,\n    flags: ParseStatementFlag,\n  ):\n    | N.Statement\n    | N.Declaration\n    | N.ImportDeclaration\n    | N.ExportDefaultDeclaration\n    | N.ExportNamedDeclaration\n    | N.ExportAllDeclaration {\n    let decorators: N.Decorator[] | null = null;\n\n    if (this.match(tt.at)) {\n      decorators = this.parseDecorators(true);\n    }\n    return this.parseStatementContent(flags, decorators);\n  }\n\n  parseStatementContent(\n    this: Parser,\n    flags: ParseStatementFlag,\n    decorators?: N.Decorator[] | null,\n  ): N.Statement {\n    const starttype = this.state.type;\n    const node = this.startNode();\n    const allowDeclaration = !!(flags & ParseStatementFlag.AllowDeclaration);\n    const allowFunctionDeclaration = !!(\n      flags & ParseStatementFlag.AllowFunctionDeclaration\n    );\n    const topLevel = flags & ParseStatementFlag.AllowImportExport;\n\n    // Most types of statements are recognized by the keyword they\n    // start with. Many are trivial to parse, some require a bit of\n    // complexity.\n\n    switch (starttype) {\n      case tt._break:\n        return this.parseBreakContinueStatement(node, /* isBreak */ true);\n      case tt._continue:\n        return this.parseBreakContinueStatement(node, /* isBreak */ false);\n      case tt._debugger:\n        return this.parseDebuggerStatement(node as Undone<N.DebuggerStatement>);\n      case tt._do:\n        return this.parseDoWhileStatement(node as Undone<N.DoWhileStatement>);\n      case tt._for:\n        return this.parseForStatement(node as Undone<N.ForStatement>);\n      case tt._function:\n        if (this.lookaheadCharCode() === charCodes.dot) break;\n        if (!allowFunctionDeclaration) {\n          this.raise(\n            this.state.strict\n              ? Errors.StrictFunction\n              : this.options.annexB\n              ? Errors.SloppyFunctionAnnexB\n              : Errors.SloppyFunction,\n            { at: this.state.startLoc },\n          );\n        }\n        return this.parseFunctionStatement(\n          node as Undone<N.FunctionDeclaration>,\n          false,\n          !allowDeclaration && allowFunctionDeclaration,\n        );\n      case tt._class:\n        if (!allowDeclaration) this.unexpected();\n        return this.parseClass(\n          this.maybeTakeDecorators(\n            decorators,\n            node as Undone<N.ClassDeclaration>,\n          ),\n          true,\n        );\n\n      case tt._if:\n        return this.parseIfStatement(node as Undone<N.IfStatement>);\n      case tt._return:\n        return this.parseReturnStatement(node as Undone<N.ReturnStatement>);\n      case tt._switch:\n        return this.parseSwitchStatement(node as Undone<N.SwitchStatement>);\n      case tt._throw:\n        return this.parseThrowStatement(node as Undone<N.ThrowStatement>);\n      case tt._try:\n        return this.parseTryStatement(node as Undone<N.TryStatement>);\n\n      case tt._await:\n        // [+Await] await [no LineTerminator here] using [no LineTerminator here] BindingList[+Using]\n        if (!this.state.containsEsc && this.startsAwaitUsing()) {\n          if (!this.isAwaitAllowed()) {\n            this.raise(Errors.AwaitUsingNotInAsyncContext, { at: node });\n          } else if (!allowDeclaration) {\n            this.raise(Errors.UnexpectedLexicalDeclaration, {\n              at: node,\n            });\n          }\n          this.next(); // eat 'await'\n          return this.parseVarStatement(\n            node as Undone<N.VariableDeclaration>,\n            \"await using\",\n          );\n        }\n        break;\n      case tt._using:\n        // using [no LineTerminator here] BindingList[+Using]\n        if (\n          this.state.containsEsc ||\n          !this.hasInLineFollowingBindingIdentifier()\n        ) {\n          break;\n        }\n        this.expectPlugin(\"explicitResourceManagement\");\n        if (!this.scope.inModule && this.scope.inTopLevel) {\n          this.raise(Errors.UnexpectedUsingDeclaration, {\n            at: this.state.startLoc,\n          });\n        } else if (!allowDeclaration) {\n          this.raise(Errors.UnexpectedLexicalDeclaration, {\n            at: this.state.startLoc,\n          });\n        }\n        return this.parseVarStatement(\n          node as Undone<N.VariableDeclaration>,\n          \"using\",\n        );\n      case tt._let: {\n        if (this.state.containsEsc) {\n          break;\n        }\n        // `let [` is an explicit negative lookahead for\n        // ExpressionStatement, so special-case it first.\n        const next = this.nextTokenStart();\n        const nextCh = this.codePointAtPos(next);\n        if (nextCh !== charCodes.leftSquareBracket) {\n          if (!allowDeclaration && this.hasFollowingLineBreak()) break;\n          if (\n            !this.chStartsBindingIdentifier(nextCh, next) &&\n            nextCh !== charCodes.leftCurlyBrace\n          ) {\n            break;\n          }\n        }\n      }\n      // fall through\n      case tt._const: {\n        if (!allowDeclaration) {\n          this.raise(Errors.UnexpectedLexicalDeclaration, {\n            at: this.state.startLoc,\n          });\n        }\n      }\n      // fall through\n      case tt._var: {\n        const kind = this.state.value;\n        return this.parseVarStatement(\n          node as Undone<N.VariableDeclaration>,\n          kind,\n        );\n      }\n      case tt._while:\n        return this.parseWhileStatement(node as Undone<N.WhileStatement>);\n      case tt._with:\n        return this.parseWithStatement(node as Undone<N.WithStatement>);\n      case tt.braceL:\n        return this.parseBlock();\n      case tt.semi:\n        return this.parseEmptyStatement(node as Undone<N.EmptyStatement>);\n      case tt._import: {\n        const nextTokenCharCode = this.lookaheadCharCode();\n        if (\n          nextTokenCharCode === charCodes.leftParenthesis || // import()\n          nextTokenCharCode === charCodes.dot // import.meta\n        ) {\n          break;\n        }\n      }\n      // fall through\n      case tt._export: {\n        if (!this.options.allowImportExportEverywhere && !topLevel) {\n          this.raise(Errors.UnexpectedImportExport, {\n            at: this.state.startLoc,\n          });\n        }\n\n        this.next(); // eat `import`/`export`\n\n        let result;\n        if (starttype === tt._import) {\n          result = this.parseImport(node as Undone<N.ImportDeclaration>);\n\n          if (\n            result.type === \"ImportDeclaration\" &&\n            (!result.importKind || result.importKind === \"value\")\n          ) {\n            this.sawUnambiguousESM = true;\n          }\n        } else {\n          result = this.parseExport(\n            node as Undone<\n              | N.ExportAllDeclaration\n              | N.ExportDefaultDeclaration\n              | N.ExportDefaultDeclaration\n            >,\n            decorators,\n          );\n\n          if (\n            (result.type === \"ExportNamedDeclaration\" &&\n              (!result.exportKind || result.exportKind === \"value\")) ||\n            (result.type === \"ExportAllDeclaration\" &&\n              (!result.exportKind || result.exportKind === \"value\")) ||\n            result.type === \"ExportDefaultDeclaration\"\n          ) {\n            this.sawUnambiguousESM = true;\n          }\n        }\n\n        this.assertModuleNodeAllowed(result);\n\n        return result;\n      }\n\n      default: {\n        if (this.isAsyncFunction()) {\n          if (!allowDeclaration) {\n            this.raise(Errors.AsyncFunctionInSingleStatementContext, {\n              at: this.state.startLoc,\n            });\n          }\n          this.next(); // eat 'async'\n          return this.parseFunctionStatement(\n            node as Undone<N.FunctionDeclaration>,\n            true,\n            !allowDeclaration && allowFunctionDeclaration,\n          );\n        }\n      }\n    }\n\n    // If the statement does not start with a statement keyword or a\n    // brace, it's an ExpressionStatement or LabeledStatement. We\n    // simply start parsing an expression, and afterwards, if the\n    // next token is a colon and the expression was a simple\n    // Identifier node, we switch to interpreting it as a label.\n    const maybeName = this.state.value;\n    const expr = this.parseExpression();\n\n    if (\n      tokenIsIdentifier(starttype) &&\n      expr.type === \"Identifier\" &&\n      this.eat(tt.colon)\n    ) {\n      return this.parseLabeledStatement(\n        node as Undone<N.LabeledStatement>,\n        maybeName,\n        // @ts-expect-error migrate to Babel types\n        expr,\n        flags,\n      );\n    } else {\n      return this.parseExpressionStatement(\n        node as Undone<N.ExpressionStatement>,\n        expr,\n        decorators,\n      );\n    }\n  }\n\n  assertModuleNodeAllowed(node: N.Node): void {\n    if (!this.options.allowImportExportEverywhere && !this.inModule) {\n      this.raise(Errors.ImportOutsideModule, { at: node });\n    }\n  }\n\n  decoratorsEnabledBeforeExport(): boolean {\n    if (this.hasPlugin(\"decorators-legacy\")) return true;\n    return (\n      this.hasPlugin(\"decorators\") &&\n      this.getPluginOption(\"decorators\", \"decoratorsBeforeExport\") !== false\n    );\n  }\n\n  // Attach the decorators to the given class.\n  // NOTE: This method changes the .start location of the class, and thus\n  // can affect comment attachment. Calling it before or after finalizing\n  // the class node (and thus finalizing its comments) changes how comments\n  // before the `class` keyword or before the final .start location of the\n  // class are attached.\n  maybeTakeDecorators<T extends Undone<N.Class>>(\n    maybeDecorators: N.Decorator[] | null,\n    classNode: T,\n    exportNode?: Undone<N.ExportDefaultDeclaration | N.ExportNamedDeclaration>,\n  ): T {\n    if (maybeDecorators) {\n      if (classNode.decorators && classNode.decorators.length > 0) {\n        // Note: decorators attachment is only attempred multiple times\n        // when the class is part of an export declaration.\n        if (\n          typeof this.getPluginOption(\n            \"decorators\",\n            \"decoratorsBeforeExport\",\n          ) !== \"boolean\"\n        ) {\n          // If `decoratorsBeforeExport` was set to `true` or `false`, we\n          // already threw an error about decorators not being in a valid\n          // position.\n          this.raise(Errors.DecoratorsBeforeAfterExport, {\n            at: classNode.decorators[0],\n          });\n        }\n        classNode.decorators.unshift(...maybeDecorators);\n      } else {\n        classNode.decorators = maybeDecorators;\n      }\n      this.resetStartLocationFromNode(classNode, maybeDecorators[0]);\n      if (exportNode) this.resetStartLocationFromNode(exportNode, classNode);\n    }\n    return classNode;\n  }\n\n  canHaveLeadingDecorator(): boolean {\n    return this.match(tt._class);\n  }\n\n  parseDecorators(this: Parser, allowExport?: boolean): N.Decorator[] {\n    const decorators = [];\n    do {\n      decorators.push(this.parseDecorator());\n    } while (this.match(tt.at));\n\n    if (this.match(tt._export)) {\n      if (!allowExport) {\n        this.unexpected();\n      }\n\n      if (!this.decoratorsEnabledBeforeExport()) {\n        this.raise(Errors.DecoratorExportClass, { at: this.state.startLoc });\n      }\n    } else if (!this.canHaveLeadingDecorator()) {\n      throw this.raise(Errors.UnexpectedLeadingDecorator, {\n        at: this.state.startLoc,\n      });\n    }\n\n    return decorators;\n  }\n\n  parseDecorator(this: Parser): N.Decorator {\n    this.expectOnePlugin([\"decorators\", \"decorators-legacy\"]);\n\n    const node = this.startNode<N.Decorator>();\n    this.next();\n\n    if (this.hasPlugin(\"decorators\")) {\n      const startLoc = this.state.startLoc;\n      let expr: N.Expression;\n\n      if (this.match(tt.parenL)) {\n        const startLoc = this.state.startLoc;\n        this.next(); // eat '('\n        expr = this.parseExpression();\n        this.expect(tt.parenR);\n        expr = this.wrapParenthesis(startLoc, expr);\n\n        const paramsStartLoc = this.state.startLoc;\n        node.expression = this.parseMaybeDecoratorArguments(expr);\n        if (\n          this.getPluginOption(\"decorators\", \"allowCallParenthesized\") ===\n            false &&\n          node.expression !== expr\n        ) {\n          this.raise(Errors.DecoratorArgumentsOutsideParentheses, {\n            at: paramsStartLoc,\n          });\n        }\n      } else {\n        expr = this.parseIdentifier(false);\n\n        while (this.eat(tt.dot)) {\n          const node = this.startNodeAt(startLoc);\n          node.object = expr;\n          if (this.match(tt.privateName)) {\n            this.classScope.usePrivateName(\n              this.state.value,\n              this.state.startLoc,\n            );\n            node.property = this.parsePrivateName();\n          } else {\n            node.property = this.parseIdentifier(true);\n          }\n          node.computed = false;\n          expr = this.finishNode(node, \"MemberExpression\");\n        }\n\n        node.expression = this.parseMaybeDecoratorArguments(expr);\n      }\n    } else {\n      node.expression = this.parseExprSubscripts();\n    }\n    return this.finishNode(node, \"Decorator\");\n  }\n\n  parseMaybeDecoratorArguments(this: Parser, expr: N.Expression): N.Expression {\n    if (this.eat(tt.parenL)) {\n      const node = this.startNodeAtNode(expr);\n      node.callee = expr;\n      node.arguments = this.parseCallExpressionArguments(tt.parenR, false);\n      this.toReferencedList(node.arguments);\n      return this.finishNode(node, \"CallExpression\");\n    }\n\n    return expr;\n  }\n\n  parseBreakContinueStatement(\n    node: Undone<N.Node>,\n    isBreak: true,\n  ): N.BreakStatement;\n  parseBreakContinueStatement(\n    node: Undone<N.Node>,\n    isBreak: false,\n  ): N.ContinueStatement;\n  parseBreakContinueStatement(\n    node: Undone<N.BreakStatement | N.ContinueStatement>,\n    isBreak: boolean,\n  ): N.BreakStatement | N.ContinueStatement {\n    this.next();\n\n    if (this.isLineTerminator()) {\n      node.label = null;\n    } else {\n      node.label = this.parseIdentifier();\n      this.semicolon();\n    }\n\n    this.verifyBreakContinue(node, isBreak);\n\n    return this.finishNode(\n      node,\n      isBreak ? \"BreakStatement\" : \"ContinueStatement\",\n    );\n  }\n\n  verifyBreakContinue(\n    node: Undone<N.BreakStatement | N.ContinueStatement>,\n    isBreak: boolean,\n  ) {\n    let i;\n    for (i = 0; i < this.state.labels.length; ++i) {\n      const lab = this.state.labels[i];\n      if (node.label == null || lab.name === node.label.name) {\n        if (lab.kind != null && (isBreak || lab.kind === \"loop\")) break;\n        if (node.label && isBreak) break;\n      }\n    }\n    if (i === this.state.labels.length) {\n      const type = isBreak ? \"BreakStatement\" : \"ContinueStatement\";\n      this.raise(Errors.IllegalBreakContinue, { at: node, type });\n    }\n  }\n\n  parseDebuggerStatement(\n    node: Undone<N.DebuggerStatement>,\n  ): N.DebuggerStatement {\n    this.next();\n    this.semicolon();\n    return this.finishNode(node, \"DebuggerStatement\");\n  }\n\n  parseHeaderExpression(this: Parser): N.Expression {\n    this.expect(tt.parenL);\n    const val = this.parseExpression();\n    this.expect(tt.parenR);\n    return val;\n  }\n\n  // https://tc39.es/ecma262/#prod-DoWhileStatement\n  parseDoWhileStatement(\n    this: Parser,\n    node: Undone<N.DoWhileStatement>,\n  ): N.DoWhileStatement {\n    this.next();\n    this.state.labels.push(loopLabel);\n\n    // Parse the loop body's body.\n    node.body =\n      // For the smartPipelines plugin: Disable topic references from outer\n      // contexts within the loop body. They are permitted in test expressions,\n      // outside of the loop body.\n      this.withSmartMixTopicForbiddingContext(() =>\n        // Parse the loop body's body.\n        this.parseStatement(),\n      );\n\n    this.state.labels.pop();\n\n    this.expect(tt._while);\n    node.test = this.parseHeaderExpression();\n    this.eat(tt.semi);\n    return this.finishNode(node, \"DoWhileStatement\");\n  }\n\n  // Disambiguating between a `for` and a `for`/`in` or `for`/`of`\n  // loop is non-trivial. Basically, we have to parse the init `var`\n  // statement or expression, disallowing the `in` operator (see\n  // the second parameter to `parseExpression`), and then check\n  // whether the next token is `in` or `of`. When there is no init\n  // part (semicolon immediately after the opening parenthesis), it\n  // is a regular `for` loop.\n\n  parseForStatement(\n    this: Parser,\n    node: Undone<N.ForStatement | N.ForInOf>,\n  ): N.ForLike {\n    this.next();\n    this.state.labels.push(loopLabel);\n\n    let awaitAt = null;\n\n    if (this.isAwaitAllowed() && this.eatContextual(tt._await)) {\n      awaitAt = this.state.lastTokStartLoc;\n    }\n    this.scope.enter(SCOPE_OTHER);\n    this.expect(tt.parenL);\n\n    if (this.match(tt.semi)) {\n      if (awaitAt !== null) {\n        this.unexpected(awaitAt);\n      }\n      return this.parseFor(node as Undone<N.ForStatement>, null);\n    }\n\n    const startsWithLet = this.isContextual(tt._let);\n    {\n      const startsWithAwaitUsing =\n        this.isContextual(tt._await) && this.startsAwaitUsing();\n      const starsWithUsingDeclaration =\n        startsWithAwaitUsing ||\n        (this.isContextual(tt._using) && this.startsUsingForOf());\n      const isLetOrUsing =\n        (startsWithLet && this.hasFollowingBindingAtom()) ||\n        starsWithUsingDeclaration;\n\n      if (this.match(tt._var) || this.match(tt._const) || isLetOrUsing) {\n        const initNode = this.startNode<N.VariableDeclaration>();\n        let kind;\n        if (startsWithAwaitUsing) {\n          kind = \"await using\";\n          if (!this.isAwaitAllowed()) {\n            this.raise(Errors.AwaitUsingNotInAsyncContext, {\n              at: this.state.startLoc,\n            });\n          }\n          this.next(); // eat 'await'\n        } else {\n          kind = this.state.value;\n        }\n        this.next();\n        this.parseVar(initNode, true, kind);\n        const init = this.finishNode(initNode, \"VariableDeclaration\");\n\n        const isForIn = this.match(tt._in);\n        if (isForIn && starsWithUsingDeclaration) {\n          this.raise(Errors.ForInUsing, { at: init });\n        }\n        if (\n          (isForIn || this.isContextual(tt._of)) &&\n          init.declarations.length === 1\n        ) {\n          return this.parseForIn(node as Undone<N.ForInOf>, init, awaitAt);\n        }\n        if (awaitAt !== null) {\n          this.unexpected(awaitAt);\n        }\n        return this.parseFor(node as Undone<N.ForStatement>, init);\n      }\n    }\n\n    // Check whether the first token is possibly a contextual keyword, so that\n    // we can forbid `for (async of` if this turns out to be a for-of loop.\n    const startsWithAsync = this.isContextual(tt._async);\n\n    const refExpressionErrors = new ExpressionErrors();\n    const init = this.parseExpression(true, refExpressionErrors);\n    const isForOf = this.isContextual(tt._of);\n    if (isForOf) {\n      // Check for leading tokens that are forbidden in for-of loops:\n      if (startsWithLet) {\n        this.raise(Errors.ForOfLet, { at: init });\n      }\n\n      if (\n        // `for await (async of []);` is allowed.\n        awaitAt === null &&\n        startsWithAsync &&\n        init.type === \"Identifier\"\n      ) {\n        // This catches the case where the `async` in `for (async of` was\n        // parsed as an identifier. If it was parsed as the start of an async\n        // arrow function (e.g. `for (async of => {} of []);`), the LVal check\n        // further down will raise a more appropriate error.\n        this.raise(Errors.ForOfAsync, { at: init });\n      }\n    }\n    if (isForOf || this.match(tt._in)) {\n      this.checkDestructuringPrivate(refExpressionErrors);\n      this.toAssignable(init, /* isLHS */ true);\n      const type = isForOf ? \"ForOfStatement\" : \"ForInStatement\";\n      this.checkLVal(init, { in: { type } });\n      return this.parseForIn(\n        node as Undone<N.ForInStatement | N.ForOfStatement>,\n        // @ts-expect-error init has been transformed to an assignable\n        init,\n        awaitAt,\n      );\n    } else {\n      this.checkExpressionErrors(refExpressionErrors, true);\n    }\n    if (awaitAt !== null) {\n      this.unexpected(awaitAt);\n    }\n    return this.parseFor(node as Undone<N.ForStatement>, init);\n  }\n\n  // https://tc39.es/ecma262/#prod-HoistableDeclaration\n  parseFunctionStatement(\n    this: Parser,\n    node: Undone<N.FunctionDeclaration>,\n    isAsync: boolean,\n    isHangingDeclaration: boolean,\n  ): N.FunctionDeclaration {\n    this.next(); // eat 'function'\n    return this.parseFunction(\n      node,\n      ParseFunctionFlag.Declaration |\n        (isHangingDeclaration ? ParseFunctionFlag.HangingDeclaration : 0) |\n        (isAsync ? ParseFunctionFlag.Async : 0),\n    );\n  }\n\n  // https://tc39.es/ecma262/#prod-IfStatement\n  parseIfStatement(this: Parser, node: Undone<N.IfStatement>) {\n    this.next();\n    node.test = this.parseHeaderExpression();\n    // Annex B.3.3\n    // https://tc39.es/ecma262/#sec-functiondeclarations-in-ifstatement-statement-clauses\n    node.consequent = this.parseStatementOrSloppyAnnexBFunctionDeclaration();\n    node.alternate = this.eat(tt._else)\n      ? this.parseStatementOrSloppyAnnexBFunctionDeclaration()\n      : null;\n    return this.finishNode(node, \"IfStatement\");\n  }\n\n  parseReturnStatement(this: Parser, node: Undone<N.ReturnStatement>) {\n    if (!this.prodParam.hasReturn && !this.options.allowReturnOutsideFunction) {\n      this.raise(Errors.IllegalReturn, { at: this.state.startLoc });\n    }\n\n    this.next();\n\n    // In `return` (and `break`/`continue`), the keywords with\n    // optional arguments, we eagerly look for a semicolon or the\n    // possibility to insert one.\n\n    if (this.isLineTerminator()) {\n      node.argument = null;\n    } else {\n      node.argument = this.parseExpression();\n      this.semicolon();\n    }\n\n    return this.finishNode(node, \"ReturnStatement\");\n  }\n\n  // https://tc39.es/ecma262/#prod-SwitchStatement\n  parseSwitchStatement(this: Parser, node: Undone<N.SwitchStatement>) {\n    this.next();\n    node.discriminant = this.parseHeaderExpression();\n    const cases: N.SwitchStatement[\"cases\"] = (node.cases = []);\n    this.expect(tt.braceL);\n    this.state.labels.push(switchLabel);\n    this.scope.enter(SCOPE_OTHER);\n\n    // Statements under must be grouped (by label) in SwitchCase\n    // nodes. `cur` is used to keep the node that we are currently\n    // adding statements to.\n\n    let cur;\n    for (let sawDefault; !this.match(tt.braceR); ) {\n      if (this.match(tt._case) || this.match(tt._default)) {\n        const isCase = this.match(tt._case);\n        if (cur) this.finishNode(cur, \"SwitchCase\");\n        // @ts-expect-error Fixme\n        cases.push((cur = this.startNode()));\n        cur.consequent = [];\n        this.next();\n        if (isCase) {\n          cur.test = this.parseExpression();\n        } else {\n          if (sawDefault) {\n            this.raise(Errors.MultipleDefaultsInSwitch, {\n              at: this.state.lastTokStartLoc,\n            });\n          }\n          sawDefault = true;\n          cur.test = null;\n        }\n        this.expect(tt.colon);\n      } else {\n        if (cur) {\n          cur.consequent.push(this.parseStatementListItem());\n        } else {\n          this.unexpected();\n        }\n      }\n    }\n    this.scope.exit();\n    if (cur) this.finishNode(cur, \"SwitchCase\");\n    this.next(); // Closing brace\n    this.state.labels.pop();\n    return this.finishNode(node, \"SwitchStatement\");\n  }\n\n  parseThrowStatement(this: Parser, node: Undone<N.ThrowStatement>) {\n    this.next();\n    if (this.hasPrecedingLineBreak()) {\n      this.raise(Errors.NewlineAfterThrow, { at: this.state.lastTokEndLoc });\n    }\n    node.argument = this.parseExpression();\n    this.semicolon();\n    return this.finishNode(node, \"ThrowStatement\");\n  }\n\n  parseCatchClauseParam(this: Parser): N.Pattern {\n    const param = this.parseBindingAtom();\n\n    this.scope.enter(\n      this.options.annexB && param.type === \"Identifier\"\n        ? SCOPE_SIMPLE_CATCH\n        : 0,\n    );\n    this.checkLVal(param, {\n      in: { type: \"CatchClause\" },\n      binding: BIND_CATCH_PARAM,\n    });\n\n    return param;\n  }\n\n  parseTryStatement(\n    this: Parser,\n    node: Undone<N.TryStatement>,\n  ): N.TryStatement {\n    this.next();\n\n    node.block = this.parseBlock();\n    node.handler = null;\n\n    if (this.match(tt._catch)) {\n      const clause = this.startNode<N.CatchClause>();\n      this.next();\n      if (this.match(tt.parenL)) {\n        this.expect(tt.parenL);\n        clause.param = this.parseCatchClauseParam();\n        this.expect(tt.parenR);\n      } else {\n        clause.param = null;\n        this.scope.enter(SCOPE_OTHER);\n      }\n\n      // Parse the catch clause's body.\n      clause.body =\n        // For the smartPipelines plugin: Disable topic references from outer\n        // contexts within the catch clause's body.\n        this.withSmartMixTopicForbiddingContext(() =>\n          // Parse the catch clause's body.\n          this.parseBlock(false, false),\n        );\n\n      this.scope.exit();\n      node.handler = this.finishNode(clause, \"CatchClause\");\n    }\n\n    node.finalizer = this.eat(tt._finally) ? this.parseBlock() : null;\n\n    if (!node.handler && !node.finalizer) {\n      this.raise(Errors.NoCatchOrFinally, { at: node });\n    }\n\n    return this.finishNode(node, \"TryStatement\");\n  }\n\n  // https://tc39.es/ecma262/#prod-VariableStatement\n  // https://tc39.es/ecma262/#prod-LexicalDeclaration\n  parseVarStatement(\n    this: Parser,\n    node: Undone<N.VariableDeclaration>,\n    kind: \"var\" | \"let\" | \"const\" | \"using\" | \"await using\",\n    allowMissingInitializer: boolean = false,\n  ): N.VariableDeclaration {\n    this.next();\n    this.parseVar(node, false, kind, allowMissingInitializer);\n    this.semicolon();\n    return this.finishNode(node, \"VariableDeclaration\");\n  }\n\n  // https://tc39.es/ecma262/#prod-WhileStatement\n  parseWhileStatement(\n    this: Parser,\n    node: Undone<N.WhileStatement>,\n  ): N.WhileStatement {\n    this.next();\n    node.test = this.parseHeaderExpression();\n    this.state.labels.push(loopLabel);\n\n    // Parse the loop body.\n    node.body =\n      // For the smartPipelines plugin:\n      // Disable topic references from outer contexts within the loop body.\n      // They are permitted in test expressions, outside of the loop body.\n      this.withSmartMixTopicForbiddingContext(() =>\n        // Parse loop body.\n        this.parseStatement(),\n      );\n\n    this.state.labels.pop();\n\n    return this.finishNode(node, \"WhileStatement\");\n  }\n\n  parseWithStatement(\n    this: Parser,\n    node: Undone<N.WithStatement>,\n  ): N.WithStatement {\n    if (this.state.strict) {\n      this.raise(Errors.StrictWith, { at: this.state.startLoc });\n    }\n    this.next();\n    node.object = this.parseHeaderExpression();\n\n    // Parse the statement body.\n    node.body =\n      // For the smartPipelines plugin:\n      // Disable topic references from outer contexts within the with statement's body.\n      // They are permitted in function default-parameter expressions, which are\n      // part of the outer context, outside of the with statement's body.\n      this.withSmartMixTopicForbiddingContext(() =>\n        // Parse the statement body.\n        this.parseStatement(),\n      );\n\n    return this.finishNode(node, \"WithStatement\");\n  }\n\n  parseEmptyStatement(node: Undone<N.EmptyStatement>): N.EmptyStatement {\n    this.next();\n    return this.finishNode(node, \"EmptyStatement\");\n  }\n\n  // https://tc39.es/ecma262/#prod-LabelledStatement\n  parseLabeledStatement(\n    this: Parser,\n    node: Undone<N.LabeledStatement>,\n    maybeName: string,\n    expr: N.Identifier,\n    flags: ParseStatementFlag,\n  ): N.LabeledStatement {\n    for (const label of this.state.labels) {\n      if (label.name === maybeName) {\n        this.raise(Errors.LabelRedeclaration, {\n          at: expr,\n          labelName: maybeName,\n        });\n      }\n    }\n\n    const kind = tokenIsLoop(this.state.type)\n      ? \"loop\"\n      : this.match(tt._switch)\n      ? \"switch\"\n      : null;\n    for (let i = this.state.labels.length - 1; i >= 0; i--) {\n      const label = this.state.labels[i];\n      if (label.statementStart === node.start) {\n        label.statementStart = this.state.start;\n        label.kind = kind;\n      } else {\n        break;\n      }\n    }\n\n    this.state.labels.push({\n      name: maybeName,\n      kind: kind,\n      statementStart: this.state.start,\n    });\n    // https://tc39.es/ecma262/#prod-LabelledItem\n    node.body =\n      flags & ParseStatementFlag.AllowLabeledFunction\n        ? this.parseStatementOrSloppyAnnexBFunctionDeclaration(true)\n        : this.parseStatement();\n\n    this.state.labels.pop();\n    node.label = expr;\n    return this.finishNode(node, \"LabeledStatement\");\n  }\n\n  parseExpressionStatement(\n    node: Undone<N.ExpressionStatement>,\n    expr: N.Expression,\n    /* eslint-disable-next-line @typescript-eslint/no-unused-vars -- used in TypeScript parser */\n    decorators: N.Decorator[] | null,\n  ) {\n    node.expression = expr;\n    this.semicolon();\n    return this.finishNode(node, \"ExpressionStatement\");\n  }\n\n  // Parse a semicolon-enclosed block of statements, handling `\"use\n  // strict\"` declarations when `allowDirectives` is true (used for\n  // function bodies).\n\n  parseBlock(\n    this: Parser,\n    allowDirectives: boolean = false,\n    createNewLexicalScope: boolean = true,\n    afterBlockParse?: (hasStrictModeDirective: boolean) => void,\n  ): N.BlockStatement {\n    const node = this.startNode<N.BlockStatement>();\n    if (allowDirectives) {\n      this.state.strictErrors.clear();\n    }\n    this.expect(tt.braceL);\n    if (createNewLexicalScope) {\n      this.scope.enter(SCOPE_OTHER);\n    }\n    this.parseBlockBody(\n      node,\n      allowDirectives,\n      false,\n      tt.braceR,\n      afterBlockParse,\n    );\n    if (createNewLexicalScope) {\n      this.scope.exit();\n    }\n    return this.finishNode(node, \"BlockStatement\");\n  }\n\n  isValidDirective(stmt: N.Statement): boolean {\n    return (\n      stmt.type === \"ExpressionStatement\" &&\n      stmt.expression.type === \"StringLiteral\" &&\n      !stmt.expression.extra.parenthesized\n    );\n  }\n\n  parseBlockBody(\n    this: Parser,\n    node: Undone<N.BlockStatementLike>,\n    allowDirectives: boolean | undefined | null,\n    topLevel: boolean,\n    end: TokenType,\n    afterBlockParse?: (hasStrictModeDirective: boolean) => void,\n  ): void {\n    const body: N.BlockStatementLike[\"body\"] = (node.body = []);\n    const directives: N.BlockStatementLike[\"directives\"] = (node.directives =\n      []);\n    this.parseBlockOrModuleBlockBody(\n      body,\n      allowDirectives ? directives : undefined,\n      topLevel,\n      end,\n      afterBlockParse,\n    );\n  }\n\n  // Undefined directives means that directives are not allowed.\n  // https://tc39.es/ecma262/#prod-Block\n  // https://tc39.es/ecma262/#prod-ModuleBody\n  parseBlockOrModuleBlockBody(\n    this: Parser,\n    body: N.Statement[],\n    directives: N.Directive[] | undefined | null,\n    topLevel: boolean,\n    end: TokenType,\n    afterBlockParse?: (hasStrictModeDirective: boolean) => void,\n  ): void {\n    const oldStrict = this.state.strict;\n    let hasStrictModeDirective = false;\n    let parsedNonDirective = false;\n\n    while (!this.match(end)) {\n      const stmt = topLevel\n        ? this.parseModuleItem()\n        : this.parseStatementListItem();\n\n      if (directives && !parsedNonDirective) {\n        if (this.isValidDirective(stmt)) {\n          const directive = this.stmtToDirective(stmt);\n          directives.push(directive);\n\n          if (\n            !hasStrictModeDirective &&\n            directive.value.value === \"use strict\"\n          ) {\n            hasStrictModeDirective = true;\n            this.setStrict(true);\n          }\n\n          continue;\n        }\n        parsedNonDirective = true;\n        // clear strict errors since the strict mode will not change within the block\n        this.state.strictErrors.clear();\n      }\n      body.push(stmt);\n    }\n\n    if (afterBlockParse) {\n      afterBlockParse.call(this, hasStrictModeDirective);\n    }\n\n    if (!oldStrict) {\n      this.setStrict(false);\n    }\n\n    this.next();\n  }\n\n  // Parse a regular `for` loop. The disambiguation code in\n  // `parseStatement` will already have parsed the init statement or\n  // expression.\n\n  parseFor(\n    this: Parser,\n    node: Undone<N.ForStatement>,\n    init?: N.VariableDeclaration | N.Expression | null,\n  ): N.ForStatement {\n    node.init = init;\n    this.semicolon(/* allowAsi */ false);\n    node.test = this.match(tt.semi) ? null : this.parseExpression();\n    this.semicolon(/* allowAsi */ false);\n    node.update = this.match(tt.parenR) ? null : this.parseExpression();\n    this.expect(tt.parenR);\n\n    // Parse the loop body.\n    node.body =\n      // For the smartPipelines plugin: Disable topic references from outer\n      // contexts within the loop body. They are permitted in test expressions,\n      // outside of the loop body.\n      this.withSmartMixTopicForbiddingContext(() =>\n        // Parse the loop body.\n        this.parseStatement(),\n      );\n\n    this.scope.exit();\n    this.state.labels.pop();\n\n    return this.finishNode(node, \"ForStatement\");\n  }\n\n  // Parse a `for`/`in` and `for`/`of` loop, which are almost\n  // same from parser's perspective.\n\n  parseForIn(\n    this: Parser,\n    node: Undone<N.ForInOf>,\n    init: N.VariableDeclaration | N.AssignmentPattern,\n    awaitAt?: Position | null,\n  ): N.ForInOf {\n    const isForIn = this.match(tt._in);\n    this.next();\n\n    if (isForIn) {\n      if (awaitAt !== null) this.unexpected(awaitAt);\n    } else {\n      node.await = awaitAt !== null;\n    }\n\n    if (\n      init.type === \"VariableDeclaration\" &&\n      init.declarations[0].init != null &&\n      (!isForIn ||\n        !this.options.annexB ||\n        this.state.strict ||\n        init.kind !== \"var\" ||\n        init.declarations[0].id.type !== \"Identifier\")\n    ) {\n      this.raise(Errors.ForInOfLoopInitializer, {\n        at: init,\n        type: isForIn ? \"ForInStatement\" : \"ForOfStatement\",\n      });\n    }\n\n    if (init.type === \"AssignmentPattern\") {\n      this.raise(Errors.InvalidLhs, {\n        at: init,\n        ancestor: { type: \"ForStatement\" },\n      });\n    }\n\n    node.left = init;\n    node.right = isForIn\n      ? this.parseExpression()\n      : this.parseMaybeAssignAllowIn();\n    this.expect(tt.parenR);\n\n    // Parse the loop body.\n    node.body =\n      // For the smartPipelines plugin:\n      // Disable topic references from outer contexts within the loop body.\n      // They are permitted in test expressions, outside of the loop body.\n      this.withSmartMixTopicForbiddingContext(() =>\n        // Parse loop body.\n        this.parseStatement(),\n      );\n\n    this.scope.exit();\n    this.state.labels.pop();\n\n    return this.finishNode(node, isForIn ? \"ForInStatement\" : \"ForOfStatement\");\n  }\n\n  // Parse a list of variable declarations.\n\n  parseVar(\n    this: Parser,\n    node: Undone<N.VariableDeclaration>,\n    isFor: boolean,\n    kind: \"var\" | \"let\" | \"const\" | \"using\" | \"await using\",\n    allowMissingInitializer: boolean = false,\n  ): Undone<N.VariableDeclaration> {\n    const declarations: N.VariableDeclarator[] = (node.declarations = []);\n    node.kind = kind;\n    for (;;) {\n      const decl = this.startNode<N.VariableDeclarator>();\n      this.parseVarId(decl, kind);\n      decl.init = !this.eat(tt.eq)\n        ? null\n        : isFor\n        ? this.parseMaybeAssignDisallowIn()\n        : this.parseMaybeAssignAllowIn();\n\n      if (decl.init === null && !allowMissingInitializer) {\n        if (\n          decl.id.type !== \"Identifier\" &&\n          !(isFor && (this.match(tt._in) || this.isContextual(tt._of)))\n        ) {\n          this.raise(Errors.DeclarationMissingInitializer, {\n            at: this.state.lastTokEndLoc,\n            kind: \"destructuring\",\n          });\n        } else if (\n          kind === \"const\" &&\n          !(this.match(tt._in) || this.isContextual(tt._of))\n        ) {\n          this.raise(Errors.DeclarationMissingInitializer, {\n            at: this.state.lastTokEndLoc,\n            kind: \"const\",\n          });\n        }\n      }\n      declarations.push(this.finishNode(decl, \"VariableDeclarator\"));\n      if (!this.eat(tt.comma)) break;\n    }\n    return node;\n  }\n\n  parseVarId(\n    this: Parser,\n    decl: Undone<N.VariableDeclarator>,\n    kind: \"var\" | \"let\" | \"const\" | \"using\" | \"await using\",\n  ): void {\n    const id = this.parseBindingAtom();\n    this.checkLVal(id, {\n      in: { type: \"VariableDeclarator\" },\n      binding: kind === \"var\" ? BIND_VAR : BIND_LEXICAL,\n    });\n    decl.id = id;\n  }\n\n  // https://tc39.es/ecma262/#prod-AsyncFunctionExpression\n  parseAsyncFunctionExpression(\n    this: Parser,\n    node: Undone<N.FunctionExpression>,\n  ): N.FunctionExpression {\n    return this.parseFunction(node, ParseFunctionFlag.Async);\n  }\n\n  // Parse a function declaration or expression (depending on the\n  // ParseFunctionFlag.Declaration flag).\n\n  parseFunction<T extends N.NormalFunction>(\n    this: Parser,\n    node: Undone<T>,\n    flags: ParseFunctionFlag = ParseFunctionFlag.Expression,\n  ): T {\n    const hangingDeclaration = flags & ParseFunctionFlag.HangingDeclaration;\n    const isDeclaration = !!(flags & ParseFunctionFlag.Declaration);\n    const requireId = isDeclaration && !(flags & ParseFunctionFlag.NullableId);\n    const isAsync = !!(flags & ParseFunctionFlag.Async);\n\n    this.initFunction(node, isAsync);\n\n    if (this.match(tt.star)) {\n      if (hangingDeclaration) {\n        this.raise(Errors.GeneratorInSingleStatementContext, {\n          at: this.state.startLoc,\n        });\n      }\n      this.next(); // eat *\n      node.generator = true;\n    }\n\n    if (isDeclaration) {\n      node.id = this.parseFunctionId(requireId);\n    }\n\n    const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;\n    this.state.maybeInArrowParameters = false;\n    this.scope.enter(SCOPE_FUNCTION);\n    this.prodParam.enter(functionFlags(isAsync, node.generator));\n\n    if (!isDeclaration) {\n      node.id = this.parseFunctionId();\n    }\n\n    this.parseFunctionParams(node, /* isConstructor */ false);\n\n    // For the smartPipelines plugin: Disable topic references from outer\n    // contexts within the function body. They are permitted in function\n    // default-parameter expressions, outside of the function body.\n    this.withSmartMixTopicForbiddingContext(() => {\n      // Parse the function body.\n      this.parseFunctionBodyAndFinish(\n        node,\n        isDeclaration ? \"FunctionDeclaration\" : \"FunctionExpression\",\n      );\n    });\n\n    this.prodParam.exit();\n    this.scope.exit();\n\n    if (isDeclaration && !hangingDeclaration) {\n      // We need to register this _after_ parsing the function body\n      // because of TypeScript body-less function declarations,\n      // which shouldn't be added to the scope.\n      this.registerFunctionStatementId(node as T);\n    }\n\n    this.state.maybeInArrowParameters = oldMaybeInArrowParameters;\n    return node as T;\n  }\n\n  parseFunctionId(requireId?: boolean): N.Identifier | undefined | null {\n    return requireId || tokenIsIdentifier(this.state.type)\n      ? this.parseIdentifier()\n      : null;\n  }\n\n  parseFunctionParams(\n    this: Parser,\n    node: Undone<N.Function>,\n    isConstructor?: boolean,\n  ): void {\n    this.expect(tt.parenL);\n    this.expressionScope.enter(newParameterDeclarationScope());\n    node.params = this.parseBindingList(\n      tt.parenR,\n      charCodes.rightParenthesis,\n      ParseBindingListFlags.IS_FUNCTION_PARAMS |\n        (isConstructor ? ParseBindingListFlags.IS_CONSTRUCTOR_PARAMS : 0),\n    );\n\n    this.expressionScope.exit();\n  }\n\n  registerFunctionStatementId(node: N.Function): void {\n    if (!node.id) return;\n\n    // If it is a regular function declaration in sloppy mode, then it is\n    // subject to Annex B semantics (BIND_FUNCTION). Otherwise, the binding\n    // mode depends on properties of the current scope (see\n    // treatFunctionsAsVar).\n    this.scope.declareName(\n      node.id.name,\n      !this.options.annexB || this.state.strict || node.generator || node.async\n        ? this.scope.treatFunctionsAsVar\n          ? BIND_VAR\n          : BIND_LEXICAL\n        : BIND_FUNCTION,\n      node.id.loc.start,\n    );\n  }\n\n  // Parse a class declaration or literal (depending on the\n  // `isStatement` parameter).\n\n  parseClass<T extends N.Class>(\n    this: Parser,\n    node: Undone<T>,\n    isStatement: /* T === ClassDeclaration */ boolean,\n    optionalId?: boolean,\n  ): T {\n    this.next(); // 'class'\n\n    // A class definition is always strict mode code.\n    const oldStrict = this.state.strict;\n    this.state.strict = true;\n\n    this.parseClassId(node, isStatement, optionalId);\n    this.parseClassSuper(node);\n    // this.state.strict is restored in parseClassBody\n    node.body = this.parseClassBody(!!node.superClass, oldStrict);\n\n    return this.finishNode(\n      node,\n      isStatement ? \"ClassDeclaration\" : \"ClassExpression\",\n    );\n  }\n\n  isClassProperty(): boolean {\n    return this.match(tt.eq) || this.match(tt.semi) || this.match(tt.braceR);\n  }\n\n  isClassMethod(): boolean {\n    return this.match(tt.parenL);\n  }\n\n  isNonstaticConstructor(method: N.ClassMethod | N.ClassProperty): boolean {\n    return (\n      !method.computed &&\n      !method.static &&\n      (method.key.name === \"constructor\" || // Identifier\n        method.key.value === \"constructor\") // String literal\n    );\n  }\n\n  // https://tc39.es/ecma262/#prod-ClassBody\n  parseClassBody(\n    this: Parser,\n    hadSuperClass: boolean,\n    oldStrict: boolean,\n  ): N.ClassBody {\n    this.classScope.enter();\n\n    const state: N.ParseClassMemberState = {\n      hadConstructor: false,\n      hadSuperClass,\n    };\n    let decorators: N.Decorator[] = [];\n    const classBody = this.startNode<N.ClassBody>();\n    classBody.body = [];\n\n    this.expect(tt.braceL);\n\n    // For the smartPipelines plugin: Disable topic references from outer\n    // contexts within the class body.\n    this.withSmartMixTopicForbiddingContext(() => {\n      // Parse the contents within the braces.\n      while (!this.match(tt.braceR)) {\n        if (this.eat(tt.semi)) {\n          if (decorators.length > 0) {\n            throw this.raise(Errors.DecoratorSemicolon, {\n              at: this.state.lastTokEndLoc,\n            });\n          }\n          continue;\n        }\n\n        if (this.match(tt.at)) {\n          decorators.push(this.parseDecorator());\n          continue;\n        }\n\n        const member = this.startNode<N.ClassMember>();\n\n        // steal the decorators if there are any\n        if (decorators.length) {\n          // @ts-expect-error Fixme\n          member.decorators = decorators;\n          this.resetStartLocationFromNode(member, decorators[0]);\n          decorators = [];\n        }\n\n        this.parseClassMember(classBody, member, state);\n\n        if (\n          // @ts-expect-error Fixme\n          member.kind === \"constructor\" &&\n          // @ts-expect-error Fixme\n          member.decorators &&\n          // @ts-expect-error Fixme\n          member.decorators.length > 0\n        ) {\n          this.raise(Errors.DecoratorConstructor, { at: member });\n        }\n      }\n    });\n\n    this.state.strict = oldStrict;\n\n    this.next(); // eat `}`\n\n    if (decorators.length) {\n      throw this.raise(Errors.TrailingDecorator, { at: this.state.startLoc });\n    }\n\n    this.classScope.exit();\n\n    return this.finishNode(classBody, \"ClassBody\");\n  }\n\n  // returns true if the current identifier is a method/field name,\n  // false if it is a modifier\n  parseClassMemberFromModifier(\n    this: Parser,\n    classBody: Undone<N.ClassBody>,\n    member: Undone<N.ClassMember>,\n  ): boolean {\n    const key = this.parseIdentifier(true); // eats the modifier\n\n    if (this.isClassMethod()) {\n      const method: N.ClassMethod = member as any;\n\n      // a method named like the modifier\n      method.kind = \"method\";\n      method.computed = false;\n      method.key = key;\n      method.static = false;\n      this.pushClassMethod(\n        classBody,\n        method,\n        false,\n        false,\n        /* isConstructor */ false,\n        false,\n      );\n      return true;\n    } else if (this.isClassProperty()) {\n      const prop: N.ClassProperty = member as any;\n\n      // a property named like the modifier\n      prop.computed = false;\n      prop.key = key;\n      prop.static = false;\n      classBody.body.push(this.parseClassProperty(prop));\n      return true;\n    }\n    this.resetPreviousNodeTrailingComments(key);\n    return false;\n  }\n\n  parseClassMember(\n    this: Parser,\n    classBody: Undone<N.ClassBody>,\n    member: Undone<N.ClassMember>,\n    state: N.ParseClassMemberState,\n  ): void {\n    const isStatic = this.isContextual(tt._static);\n\n    if (isStatic) {\n      if (this.parseClassMemberFromModifier(classBody, member)) {\n        // a class element named 'static'\n        return;\n      }\n      if (this.eat(tt.braceL)) {\n        this.parseClassStaticBlock(classBody, member as any as N.StaticBlock);\n        return;\n      }\n    }\n\n    this.parseClassMemberWithIsStatic(classBody, member, state, isStatic);\n  }\n\n  parseClassMemberWithIsStatic(\n    this: Parser,\n    classBody: Undone<N.ClassBody>,\n    member: Undone<N.ClassMember>,\n    state: N.ParseClassMemberState,\n    isStatic: boolean,\n  ) {\n    const publicMethod = member as N.ClassMethod;\n    const privateMethod = member as N.ClassPrivateMethod;\n    const publicProp = member as N.ClassProperty;\n    const privateProp = member as N.ClassPrivateProperty;\n    const accessorProp = member as N.ClassAccessorProperty;\n\n    const method: typeof publicMethod | typeof privateMethod = publicMethod;\n    const publicMember: typeof publicMethod | typeof publicProp = publicMethod;\n\n    member.static = isStatic;\n    this.parsePropertyNamePrefixOperator(member);\n\n    if (this.eat(tt.star)) {\n      // a generator\n      method.kind = \"method\";\n      const isPrivateName = this.match(tt.privateName);\n      this.parseClassElementName(method);\n\n      if (isPrivateName) {\n        // Private generator method\n        this.pushClassPrivateMethod(classBody, privateMethod, true, false);\n        return;\n      }\n\n      if (this.isNonstaticConstructor(publicMethod)) {\n        this.raise(Errors.ConstructorIsGenerator, {\n          at: publicMethod.key,\n        });\n      }\n\n      this.pushClassMethod(\n        classBody,\n        publicMethod,\n        true,\n        false,\n        /* isConstructor */ false,\n        false,\n      );\n\n      return;\n    }\n\n    const isContextual =\n      tokenIsIdentifier(this.state.type) && !this.state.containsEsc;\n    const isPrivate = this.match(tt.privateName);\n    const key = this.parseClassElementName(member);\n    const maybeQuestionTokenStartLoc = this.state.startLoc;\n\n    this.parsePostMemberNameModifiers(publicMember);\n\n    if (this.isClassMethod()) {\n      method.kind = \"method\";\n\n      if (isPrivate) {\n        this.pushClassPrivateMethod(classBody, privateMethod, false, false);\n        return;\n      }\n\n      // a normal method\n      const isConstructor = this.isNonstaticConstructor(publicMethod);\n      let allowsDirectSuper = false;\n      if (isConstructor) {\n        publicMethod.kind = \"constructor\";\n\n        // TypeScript allows multiple overloaded constructor declarations.\n        if (state.hadConstructor && !this.hasPlugin(\"typescript\")) {\n          this.raise(Errors.DuplicateConstructor, { at: key });\n        }\n        if (isConstructor && this.hasPlugin(\"typescript\") && member.override) {\n          this.raise(Errors.OverrideOnConstructor, { at: key });\n        }\n        state.hadConstructor = true;\n        allowsDirectSuper = state.hadSuperClass;\n      }\n\n      this.pushClassMethod(\n        classBody,\n        publicMethod,\n        false,\n        false,\n        isConstructor,\n        allowsDirectSuper,\n      );\n    } else if (this.isClassProperty()) {\n      if (isPrivate) {\n        this.pushClassPrivateProperty(classBody, privateProp);\n      } else {\n        this.pushClassProperty(classBody, publicProp);\n      }\n    } else if (\n      isContextual &&\n      key.name === \"async\" &&\n      !this.isLineTerminator()\n    ) {\n      // an async method\n      this.resetPreviousNodeTrailingComments(key);\n      const isGenerator = this.eat(tt.star);\n\n      if (publicMember.optional) {\n        this.unexpected(maybeQuestionTokenStartLoc);\n      }\n\n      method.kind = \"method\";\n      // The so-called parsed name would have been \"async\": get the real name.\n      const isPrivate = this.match(tt.privateName);\n      this.parseClassElementName(method);\n      this.parsePostMemberNameModifiers(publicMember);\n\n      if (isPrivate) {\n        // private async method\n        this.pushClassPrivateMethod(\n          classBody,\n          privateMethod,\n          isGenerator,\n          true,\n        );\n      } else {\n        if (this.isNonstaticConstructor(publicMethod)) {\n          this.raise(Errors.ConstructorIsAsync, { at: publicMethod.key });\n        }\n\n        this.pushClassMethod(\n          classBody,\n          publicMethod,\n          isGenerator,\n          true,\n          /* isConstructor */ false,\n          false,\n        );\n      }\n    } else if (\n      isContextual &&\n      (key.name === \"get\" || key.name === \"set\") &&\n      !(this.match(tt.star) && this.isLineTerminator())\n    ) {\n      // `get\\n*` is an uninitialized property named 'get' followed by a generator.\n      // a getter or setter\n      this.resetPreviousNodeTrailingComments(key);\n      method.kind = key.name;\n      // The so-called parsed name would have been \"get/set\": get the real name.\n      const isPrivate = this.match(tt.privateName);\n      this.parseClassElementName(publicMethod);\n\n      if (isPrivate) {\n        // private getter/setter\n        this.pushClassPrivateMethod(classBody, privateMethod, false, false);\n      } else {\n        if (this.isNonstaticConstructor(publicMethod)) {\n          this.raise(Errors.ConstructorIsAccessor, { at: publicMethod.key });\n        }\n        this.pushClassMethod(\n          classBody,\n          publicMethod,\n          false,\n          false,\n          /* isConstructor */ false,\n          false,\n        );\n      }\n\n      this.checkGetterSetterParams(publicMethod);\n    } else if (\n      isContextual &&\n      key.name === \"accessor\" &&\n      !this.isLineTerminator()\n    ) {\n      this.expectPlugin(\"decoratorAutoAccessors\");\n      this.resetPreviousNodeTrailingComments(key);\n\n      // The so-called parsed name would have been \"accessor\": get the real name.\n      const isPrivate = this.match(tt.privateName);\n      this.parseClassElementName(publicProp);\n      this.pushClassAccessorProperty(classBody, accessorProp, isPrivate);\n    } else if (this.isLineTerminator()) {\n      // an uninitialized class property (due to ASI, since we don't otherwise recognize the next token)\n      if (isPrivate) {\n        this.pushClassPrivateProperty(classBody, privateProp);\n      } else {\n        this.pushClassProperty(classBody, publicProp);\n      }\n    } else {\n      this.unexpected();\n    }\n  }\n\n  // https://tc39.es/ecma262/#prod-ClassElementName\n  parseClassElementName(\n    this: Parser,\n    member: Undone<N.ClassMember>,\n  ): N.Expression | N.Identifier {\n    const { type, value } = this.state;\n    if (\n      (type === tt.name || type === tt.string) &&\n      member.static &&\n      value === \"prototype\"\n    ) {\n      this.raise(Errors.StaticPrototype, { at: this.state.startLoc });\n    }\n\n    if (type === tt.privateName) {\n      if (value === \"constructor\") {\n        this.raise(Errors.ConstructorClassPrivateField, {\n          at: this.state.startLoc,\n        });\n      }\n      const key = this.parsePrivateName();\n      member.key = key;\n      return key;\n    }\n\n    return this.parsePropertyName(member);\n  }\n\n  parseClassStaticBlock(\n    this: Parser,\n    classBody: Undone<N.ClassBody>,\n    member: Undone<\n      N.StaticBlock & {\n        decorators?: Array<N.Decorator>;\n      }\n    >,\n  ) {\n    // Start a new lexical scope\n    this.scope.enter(SCOPE_CLASS | SCOPE_STATIC_BLOCK | SCOPE_SUPER);\n    // Start a new scope with regard to loop labels\n    const oldLabels = this.state.labels;\n    this.state.labels = [];\n    // ClassStaticBlockStatementList:\n    //   StatementList[~Yield, ~Await, ~Return] opt\n    this.prodParam.enter(PARAM);\n    const body: N.Node[] = (member.body = []);\n    this.parseBlockOrModuleBlockBody(body, undefined, false, tt.braceR);\n    this.prodParam.exit();\n    this.scope.exit();\n    this.state.labels = oldLabels;\n    classBody.body.push(this.finishNode<N.StaticBlock>(member, \"StaticBlock\"));\n    if (member.decorators?.length) {\n      this.raise(Errors.DecoratorStaticBlock, { at: member });\n    }\n  }\n\n  pushClassProperty(\n    this: Parser,\n    classBody: Undone<N.ClassBody>,\n    prop: N.ClassProperty,\n  ) {\n    if (\n      !prop.computed &&\n      (prop.key.name === \"constructor\" || prop.key.value === \"constructor\")\n    ) {\n      // Non-computed field, which is either an identifier named \"constructor\"\n      // or a string literal named \"constructor\"\n      this.raise(Errors.ConstructorClassField, { at: prop.key });\n    }\n\n    classBody.body.push(this.parseClassProperty(prop));\n  }\n\n  pushClassPrivateProperty(\n    this: Parser,\n    classBody: Undone<N.ClassBody>,\n    prop: Undone<N.ClassPrivateProperty>,\n  ) {\n    const node = this.parseClassPrivateProperty(prop);\n    classBody.body.push(node);\n\n    this.classScope.declarePrivateName(\n      this.getPrivateNameSV(node.key),\n      CLASS_ELEMENT_OTHER,\n      node.key.loc.start,\n    );\n  }\n\n  pushClassAccessorProperty(\n    this: Parser,\n    classBody: Undone<N.ClassBody>,\n    prop: N.ClassAccessorProperty,\n    isPrivate: boolean,\n  ) {\n    if (!isPrivate && !prop.computed) {\n      // Not private, so not node is not a PrivateName and we can safely cast\n      const key = prop.key as N.Expression;\n\n      if (key.name === \"constructor\" || key.value === \"constructor\") {\n        // Non-computed field, which is either an identifier named \"constructor\"\n        // or a string literal named \"constructor\"\n        this.raise(Errors.ConstructorClassField, { at: key });\n      }\n    }\n\n    const node = this.parseClassAccessorProperty(prop);\n    classBody.body.push(node);\n\n    if (isPrivate) {\n      this.classScope.declarePrivateName(\n        this.getPrivateNameSV(node.key),\n        CLASS_ELEMENT_OTHER,\n        node.key.loc.start,\n      );\n    }\n  }\n\n  pushClassMethod(\n    this: Parser,\n    classBody: Undone<N.ClassBody>,\n    method: Undone<N.ClassMethod>,\n    isGenerator: boolean,\n    isAsync: boolean,\n    isConstructor: boolean,\n    allowsDirectSuper: boolean,\n  ): void {\n    classBody.body.push(\n      this.parseMethod(\n        method,\n        isGenerator,\n        isAsync,\n        isConstructor,\n        allowsDirectSuper,\n        \"ClassMethod\",\n        true,\n      ),\n    );\n  }\n\n  pushClassPrivateMethod(\n    this: Parser,\n    classBody: Undone<N.ClassBody>,\n    method: Undone<N.ClassPrivateMethod>,\n    isGenerator: boolean,\n    isAsync: boolean,\n  ): void {\n    const node = this.parseMethod(\n      method,\n      isGenerator,\n      isAsync,\n      /* isConstructor */ false,\n      false,\n      \"ClassPrivateMethod\",\n      true,\n    );\n    classBody.body.push(node);\n\n    const kind =\n      node.kind === \"get\"\n        ? node.static\n          ? CLASS_ELEMENT_STATIC_GETTER\n          : CLASS_ELEMENT_INSTANCE_GETTER\n        : node.kind === \"set\"\n        ? node.static\n          ? CLASS_ELEMENT_STATIC_SETTER\n          : CLASS_ELEMENT_INSTANCE_SETTER\n        : CLASS_ELEMENT_OTHER;\n    this.declareClassPrivateMethodInScope(node, kind);\n  }\n\n  declareClassPrivateMethodInScope(\n    node: Undone<\n      N.ClassPrivateMethod | N.EstreeMethodDefinition | N.TSDeclareMethod\n    >,\n    kind: number,\n  ) {\n    this.classScope.declarePrivateName(\n      this.getPrivateNameSV(node.key),\n      kind,\n      node.key.loc.start,\n    );\n  }\n\n  // Overridden in typescript.js\n  parsePostMemberNameModifiers(\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    methodOrProp: Undone<N.ClassMethod | N.ClassProperty>,\n  ): void {}\n\n  // https://tc39.es/ecma262/#prod-FieldDefinition\n  parseClassPrivateProperty(\n    this: Parser,\n    node: Undone<N.ClassPrivateProperty>,\n  ): N.ClassPrivateProperty {\n    this.parseInitializer(node);\n    this.semicolon();\n    return this.finishNode(node, \"ClassPrivateProperty\");\n  }\n\n  // https://tc39.es/ecma262/#prod-FieldDefinition\n  parseClassProperty(this: Parser, node: N.ClassProperty): N.ClassProperty {\n    this.parseInitializer(node);\n    this.semicolon();\n    return this.finishNode(node, \"ClassProperty\");\n  }\n\n  parseClassAccessorProperty(\n    this: Parser,\n    node: N.ClassAccessorProperty,\n  ): N.ClassAccessorProperty {\n    this.parseInitializer(node);\n    this.semicolon();\n    return this.finishNode(node, \"ClassAccessorProperty\");\n  }\n\n  // https://tc39.es/ecma262/#prod-Initializer\n  parseInitializer(\n    this: Parser,\n    node: Undone<\n      N.ClassProperty | N.ClassPrivateProperty | N.ClassAccessorProperty\n    >,\n  ): void {\n    this.scope.enter(SCOPE_CLASS | SCOPE_SUPER);\n    this.expressionScope.enter(newExpressionScope());\n    this.prodParam.enter(PARAM);\n    node.value = this.eat(tt.eq) ? this.parseMaybeAssignAllowIn() : null;\n    this.expressionScope.exit();\n    this.prodParam.exit();\n    this.scope.exit();\n  }\n\n  parseClassId(\n    node: Undone<N.Class>,\n    isStatement: boolean,\n    optionalId?: boolean | null,\n    bindingType: BindingTypes = BIND_CLASS,\n  ): void {\n    if (tokenIsIdentifier(this.state.type)) {\n      node.id = this.parseIdentifier();\n      if (isStatement) {\n        this.declareNameFromIdentifier(node.id, bindingType);\n      }\n    } else {\n      if (optionalId || !isStatement) {\n        node.id = null;\n      } else {\n        throw this.raise(Errors.MissingClassName, { at: this.state.startLoc });\n      }\n    }\n  }\n\n  // https://tc39.es/ecma262/#prod-ClassHeritage\n  parseClassSuper(this: Parser, node: Undone<N.Class>): void {\n    node.superClass = this.eat(tt._extends) ? this.parseExprSubscripts() : null;\n  }\n\n  // Parses module export declaration.\n  // https://tc39.es/ecma262/#prod-ExportDeclaration\n\n  parseExport(\n    this: Parser,\n    node: Undone<\n      | N.ExportDefaultDeclaration\n      | N.ExportAllDeclaration\n      | N.ExportNamedDeclaration\n    >,\n    decorators: N.Decorator[] | null,\n  ): N.AnyExport {\n    const maybeDefaultIdentifier = this.parseMaybeImportPhase(\n      node,\n      /* isExport */ true,\n    );\n    const hasDefault = this.maybeParseExportDefaultSpecifier(\n      node,\n      maybeDefaultIdentifier,\n    );\n    const parseAfterDefault = !hasDefault || this.eat(tt.comma);\n    const hasStar =\n      parseAfterDefault &&\n      this.eatExportStar(\n        // @ts-expect-error todo(flow->ts)\n        node,\n      );\n    const hasNamespace =\n      hasStar &&\n      this.maybeParseExportNamespaceSpecifier(\n        // @ts-expect-error todo(flow->ts)\n        node,\n      );\n    const parseAfterNamespace =\n      parseAfterDefault && (!hasNamespace || this.eat(tt.comma));\n    const isFromRequired = hasDefault || hasStar;\n\n    if (hasStar && !hasNamespace) {\n      if (hasDefault) this.unexpected();\n      if (decorators) {\n        throw this.raise(Errors.UnsupportedDecoratorExport, { at: node });\n      }\n      this.parseExportFrom(node as Undone<N.ExportNamedDeclaration>, true);\n\n      return this.finishNode(node, \"ExportAllDeclaration\");\n    }\n\n    const hasSpecifiers = this.maybeParseExportNamedSpecifiers(\n      // @ts-expect-error todo(flow->ts)\n      node,\n    );\n\n    if (hasDefault && parseAfterDefault && !hasStar && !hasSpecifiers) {\n      this.unexpected(null, tt.braceL);\n    }\n\n    if (hasNamespace && parseAfterNamespace) {\n      this.unexpected(null, tt._from);\n    }\n\n    let hasDeclaration;\n    if (isFromRequired || hasSpecifiers) {\n      hasDeclaration = false;\n      if (decorators) {\n        throw this.raise(Errors.UnsupportedDecoratorExport, { at: node });\n      }\n      this.parseExportFrom(\n        node as Undone<N.ExportNamedDeclaration>,\n        isFromRequired,\n      );\n    } else {\n      hasDeclaration = this.maybeParseExportDeclaration(\n        node as Undone<N.ExportNamedDeclaration>,\n      );\n    }\n\n    if (isFromRequired || hasSpecifiers || hasDeclaration) {\n      const node2 = node as Undone<N.ExportNamedDeclaration>;\n      this.checkExport(node2, true, false, !!node2.source);\n      if (node2.declaration?.type === \"ClassDeclaration\") {\n        this.maybeTakeDecorators(decorators, node2.declaration, node2);\n      } else if (decorators) {\n        throw this.raise(Errors.UnsupportedDecoratorExport, { at: node });\n      }\n      return this.finishNode(node2, \"ExportNamedDeclaration\");\n    }\n\n    if (this.eat(tt._default)) {\n      const node2 = node as Undone<N.ExportDefaultDeclaration>;\n      // export default ...\n      const decl = this.parseExportDefaultExpression();\n      node2.declaration = decl;\n\n      if (decl.type === \"ClassDeclaration\") {\n        this.maybeTakeDecorators(decorators, decl as N.ClassDeclaration, node2);\n      } else if (decorators) {\n        throw this.raise(Errors.UnsupportedDecoratorExport, { at: node });\n      }\n\n      this.checkExport(node2, true, true);\n\n      return this.finishNode(node2, \"ExportDefaultDeclaration\");\n    }\n\n    this.unexpected(null, tt.braceL);\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  eatExportStar(node: N.Node): boolean {\n    return this.eat(tt.star);\n  }\n\n  maybeParseExportDefaultSpecifier(\n    node: Undone<\n      | N.ExportDefaultDeclaration\n      | N.ExportAllDeclaration\n      | N.ExportNamedDeclaration\n    >,\n    maybeDefaultIdentifier: N.Identifier | null,\n  ): node is Undone<N.ExportNamedDeclaration> {\n    if (maybeDefaultIdentifier || this.isExportDefaultSpecifier()) {\n      // export defaultObj ...\n      this.expectPlugin(\"exportDefaultFrom\", maybeDefaultIdentifier?.loc.start);\n      const id = maybeDefaultIdentifier || this.parseIdentifier(true);\n      const specifier = this.startNodeAtNode<N.ExportDefaultSpecifier>(id);\n      specifier.exported = id;\n      (node as Undone<N.ExportNamedDeclaration>).specifiers = [\n        this.finishNode(specifier, \"ExportDefaultSpecifier\"),\n      ];\n      return true;\n    }\n    return false;\n  }\n\n  maybeParseExportNamespaceSpecifier(node: N.Node): boolean {\n    if (this.isContextual(tt._as)) {\n      if (!node.specifiers) node.specifiers = [];\n\n      const specifier = this.startNodeAt(this.state.lastTokStartLoc);\n\n      this.next();\n\n      specifier.exported = this.parseModuleExportName();\n      node.specifiers.push(\n        this.finishNode(specifier, \"ExportNamespaceSpecifier\"),\n      );\n      return true;\n    }\n    return false;\n  }\n\n  maybeParseExportNamedSpecifiers(node: N.Node): boolean {\n    if (this.match(tt.braceL)) {\n      if (!node.specifiers) node.specifiers = [];\n      const isTypeExport = node.exportKind === \"type\";\n      node.specifiers.push(...this.parseExportSpecifiers(isTypeExport));\n\n      node.source = null;\n      node.declaration = null;\n      if (this.hasPlugin(\"importAssertions\")) {\n        node.assertions = [];\n      }\n\n      return true;\n    }\n    return false;\n  }\n\n  maybeParseExportDeclaration(\n    this: Parser,\n    node: Undone<N.ExportNamedDeclaration>,\n  ): boolean {\n    if (this.shouldParseExportDeclaration()) {\n      node.specifiers = [];\n      node.source = null;\n      if (this.hasPlugin(\"importAssertions\")) {\n        node.assertions = [];\n      }\n      node.declaration = this.parseExportDeclaration(node);\n      return true;\n    }\n    return false;\n  }\n\n  isAsyncFunction(): boolean {\n    if (!this.isContextual(tt._async)) return false;\n    const next = this.nextTokenInLineStart();\n    return this.isUnparsedContextual(next, \"function\");\n  }\n\n  parseExportDefaultExpression(this: Parser): N.Expression | N.Declaration {\n    const expr = this.startNode();\n\n    if (this.match(tt._function)) {\n      this.next();\n      return this.parseFunction(\n        expr as Undone<N.FunctionDeclaration>,\n        ParseFunctionFlag.Declaration | ParseFunctionFlag.NullableId,\n      );\n    } else if (this.isAsyncFunction()) {\n      this.next(); // eat 'async'\n      this.next(); // eat 'function'\n      return this.parseFunction(\n        expr as Undone<N.FunctionDeclaration>,\n        ParseFunctionFlag.Declaration |\n          ParseFunctionFlag.NullableId |\n          ParseFunctionFlag.Async,\n      );\n    }\n\n    if (this.match(tt._class)) {\n      return this.parseClass(expr as Undone<N.ClassExpression>, true, true);\n    }\n\n    if (this.match(tt.at)) {\n      if (\n        this.hasPlugin(\"decorators\") &&\n        this.getPluginOption(\"decorators\", \"decoratorsBeforeExport\") === true\n      ) {\n        this.raise(Errors.DecoratorBeforeExport, { at: this.state.startLoc });\n      }\n      return this.parseClass(\n        this.maybeTakeDecorators(\n          this.parseDecorators(false),\n          this.startNode<N.ClassDeclaration>(),\n        ),\n        true,\n        true,\n      );\n    }\n\n    if (this.match(tt._const) || this.match(tt._var) || this.isLet()) {\n      throw this.raise(Errors.UnsupportedDefaultExport, {\n        at: this.state.startLoc,\n      });\n    }\n\n    const res = this.parseMaybeAssignAllowIn();\n    this.semicolon();\n    return res;\n  }\n\n  // https://tc39.es/ecma262/#prod-ExportDeclaration\n  parseExportDeclaration(\n    this: Parser,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    node: Undone<N.ExportNamedDeclaration>,\n  ): N.Declaration | undefined | null {\n    if (this.match(tt._class)) {\n      const node = this.parseClass(\n        this.startNode<N.ClassDeclaration>(),\n        true,\n        false,\n      );\n      return node;\n    }\n    return this.parseStatementListItem() as N.Declaration;\n  }\n\n  isExportDefaultSpecifier(): boolean {\n    const { type } = this.state;\n    if (tokenIsIdentifier(type)) {\n      if ((type === tt._async && !this.state.containsEsc) || type === tt._let) {\n        return false;\n      }\n      if (\n        (type === tt._type || type === tt._interface) &&\n        !this.state.containsEsc\n      ) {\n        const { type: nextType } = this.lookahead();\n        // If we see any variable name other than `from` after `type` keyword,\n        // we consider it as flow/typescript type exports\n        // note that this approach may fail on some pedantic cases\n        // export type from = number\n        if (\n          (tokenIsIdentifier(nextType) && nextType !== tt._from) ||\n          nextType === tt.braceL\n        ) {\n          this.expectOnePlugin([\"flow\", \"typescript\"]);\n          return false;\n        }\n      }\n    } else if (!this.match(tt._default)) {\n      return false;\n    }\n\n    const next = this.nextTokenStart();\n    const hasFrom = this.isUnparsedContextual(next, \"from\");\n    if (\n      this.input.charCodeAt(next) === charCodes.comma ||\n      (tokenIsIdentifier(this.state.type) && hasFrom)\n    ) {\n      return true;\n    }\n    // lookahead again when `export default from` is seen\n    if (this.match(tt._default) && hasFrom) {\n      const nextAfterFrom = this.input.charCodeAt(\n        this.nextTokenStartSince(next + 4),\n      );\n      return (\n        nextAfterFrom === charCodes.quotationMark ||\n        nextAfterFrom === charCodes.apostrophe\n      );\n    }\n    return false;\n  }\n\n  parseExportFrom(\n    this: Parser,\n    node: Undone<N.ExportNamedDeclaration>,\n    expect?: boolean,\n  ): void {\n    if (this.eatContextual(tt._from)) {\n      node.source = this.parseImportSource();\n      this.checkExport(node);\n      this.maybeParseImportAttributes(node);\n      this.checkJSONModuleImport(node);\n    } else if (expect) {\n      this.unexpected();\n    }\n\n    this.semicolon();\n  }\n\n  shouldParseExportDeclaration(): boolean {\n    const { type } = this.state;\n    if (type === tt.at) {\n      this.expectOnePlugin([\"decorators\", \"decorators-legacy\"]);\n      if (this.hasPlugin(\"decorators\")) {\n        if (\n          this.getPluginOption(\"decorators\", \"decoratorsBeforeExport\") === true\n        ) {\n          this.raise(Errors.DecoratorBeforeExport, {\n            at: this.state.startLoc,\n          });\n        }\n\n        return true;\n      }\n    }\n\n    return (\n      type === tt._var ||\n      type === tt._const ||\n      type === tt._function ||\n      type === tt._class ||\n      this.isLet() ||\n      this.isAsyncFunction()\n    );\n  }\n\n  checkExport(\n    node: Undone<N.ExportNamedDeclaration | N.ExportDefaultDeclaration>,\n    checkNames?: boolean,\n    isDefault?: boolean,\n    isFrom?: boolean,\n  ): void {\n    if (checkNames) {\n      // Check for duplicate exports\n      if (isDefault) {\n        // Default exports\n        this.checkDuplicateExports(node, \"default\");\n        if (this.hasPlugin(\"exportDefaultFrom\")) {\n          const declaration = (node as any as N.ExportDefaultDeclaration)\n            .declaration;\n          if (\n            declaration.type === \"Identifier\" &&\n            declaration.name === \"from\" &&\n            declaration.end - declaration.start === 4 && // does not contain escape\n            !declaration.extra?.parenthesized\n          ) {\n            this.raise(Errors.ExportDefaultFromAsIdentifier, {\n              at: declaration,\n            });\n          }\n        }\n        // @ts-expect-error node.specifiers may not exist\n      } else if (node.specifiers && node.specifiers.length) {\n        // Named exports\n        // @ts-expect-error node.specifiers may not exist\n        for (const specifier of node.specifiers) {\n          const { exported } = specifier;\n          const exportName =\n            exported.type === \"Identifier\" ? exported.name : exported.value;\n          this.checkDuplicateExports(specifier, exportName);\n          if (!isFrom && specifier.local) {\n            const { local } = specifier;\n            if (local.type !== \"Identifier\") {\n              this.raise(Errors.ExportBindingIsString, {\n                at: specifier,\n                localName: local.value,\n                exportName,\n              });\n            } else {\n              // check for keywords used as local names\n              this.checkReservedWord(local.name, local.loc.start, true, false);\n              // check if export is defined\n              this.scope.checkLocalExport(local);\n            }\n          }\n        }\n      } else if (node.declaration) {\n        // Exported declarations\n        if (\n          node.declaration.type === \"FunctionDeclaration\" ||\n          node.declaration.type === \"ClassDeclaration\"\n        ) {\n          const id = node.declaration.id;\n          if (!id) throw new Error(\"Assertion failure\");\n\n          this.checkDuplicateExports(node, id.name);\n        } else if (node.declaration.type === \"VariableDeclaration\") {\n          for (const declaration of node.declaration.declarations) {\n            this.checkDeclaration(declaration.id);\n          }\n        }\n      }\n    }\n  }\n\n  checkDeclaration(node: N.Pattern | N.ObjectProperty): void {\n    if (node.type === \"Identifier\") {\n      this.checkDuplicateExports(node, node.name);\n    } else if (node.type === \"ObjectPattern\") {\n      for (const prop of node.properties) {\n        this.checkDeclaration(prop);\n      }\n    } else if (node.type === \"ArrayPattern\") {\n      for (const elem of node.elements) {\n        if (elem) {\n          this.checkDeclaration(elem);\n        }\n      }\n    } else if (node.type === \"ObjectProperty\") {\n      // @ts-expect-error migrate to Babel types\n      this.checkDeclaration(node.value);\n    } else if (node.type === \"RestElement\") {\n      this.checkDeclaration(node.argument);\n    } else if (node.type === \"AssignmentPattern\") {\n      this.checkDeclaration(node.left);\n    }\n  }\n\n  checkDuplicateExports(\n    node: Undone<\n      | N.Identifier\n      | N.StringLiteral\n      | N.ExportNamedDeclaration\n      | N.ExportSpecifier\n      | N.ExportDefaultSpecifier\n    >,\n    exportName: string,\n  ): void {\n    if (this.exportedIdentifiers.has(exportName)) {\n      if (exportName === \"default\") {\n        this.raise(Errors.DuplicateDefaultExport, { at: node });\n      } else {\n        this.raise(Errors.DuplicateExport, { at: node, exportName });\n      }\n    }\n    this.exportedIdentifiers.add(exportName);\n  }\n\n  // Parses a comma-separated list of module exports.\n\n  parseExportSpecifiers(isInTypeExport: boolean): Array<N.ExportSpecifier> {\n    const nodes = [];\n    let first = true;\n\n    // export { x, y as z } [from '...']\n    this.expect(tt.braceL);\n\n    while (!this.eat(tt.braceR)) {\n      if (first) {\n        first = false;\n      } else {\n        this.expect(tt.comma);\n        if (this.eat(tt.braceR)) break;\n      }\n      const isMaybeTypeOnly = this.isContextual(tt._type);\n      const isString = this.match(tt.string);\n      const node = this.startNode();\n      node.local = this.parseModuleExportName();\n      nodes.push(\n        this.parseExportSpecifier(\n          node,\n          isString,\n          isInTypeExport,\n          isMaybeTypeOnly,\n        ),\n      );\n    }\n\n    return nodes;\n  }\n\n  parseExportSpecifier(\n    node: any,\n    isString: boolean,\n    /* eslint-disable @typescript-eslint/no-unused-vars -- used in TypeScript parser */\n    isInTypeExport: boolean,\n    isMaybeTypeOnly: boolean,\n    /* eslint-enable @typescript-eslint/no-unused-vars */\n  ): N.ExportSpecifier {\n    if (this.eatContextual(tt._as)) {\n      node.exported = this.parseModuleExportName();\n    } else if (isString) {\n      node.exported = cloneStringLiteral(node.local);\n    } else if (!node.exported) {\n      node.exported = cloneIdentifier(node.local);\n    }\n    return this.finishNode<N.ExportSpecifier>(node, \"ExportSpecifier\");\n  }\n\n  // https://tc39.es/ecma262/#prod-ModuleExportName\n  parseModuleExportName(): N.StringLiteral | N.Identifier {\n    if (this.match(tt.string)) {\n      const result = this.parseStringLiteral(this.state.value);\n      const surrogate = result.value.match(loneSurrogate);\n      if (surrogate) {\n        this.raise(Errors.ModuleExportNameHasLoneSurrogate, {\n          at: result,\n          surrogateCharCode: surrogate[0].charCodeAt(0),\n        });\n      }\n      return result;\n    }\n    return this.parseIdentifier(true);\n  }\n\n  isJSONModuleImport(\n    node: Undone<\n      N.ExportAllDeclaration | N.ExportNamedDeclaration | N.ImportDeclaration\n    >,\n  ): boolean {\n    if (node.assertions != null) {\n      return node.assertions.some(({ key, value }) => {\n        return (\n          value.value === \"json\" &&\n          (key.type === \"Identifier\"\n            ? key.name === \"type\"\n            : key.value === \"type\")\n        );\n      });\n    }\n    return false;\n  }\n\n  checkImportReflection(node: Undone<N.ImportDeclaration>) {\n    if (node.module) {\n      if (\n        node.specifiers.length !== 1 ||\n        node.specifiers[0].type !== \"ImportDefaultSpecifier\"\n      ) {\n        this.raise(Errors.ImportReflectionNotBinding, {\n          at: node.specifiers[0].loc.start,\n        });\n      }\n      if (node.assertions?.length > 0) {\n        this.raise(Errors.ImportReflectionHasAssertion, {\n          at: node.specifiers[0].loc.start,\n        });\n      }\n    }\n  }\n\n  checkJSONModuleImport(\n    node: Undone<\n      N.ExportAllDeclaration | N.ExportNamedDeclaration | N.ImportDeclaration\n    >,\n  ) {\n    // @ts-expect-error Fixme: node.type must be undefined because they are undone\n    if (this.isJSONModuleImport(node) && node.type !== \"ExportAllDeclaration\") {\n      // @ts-expect-error specifiers may not index node\n      const { specifiers } = node;\n      if (specifiers != null) {\n        // @ts-expect-error refine specifier types\n        const nonDefaultNamedSpecifier = specifiers.find(specifier => {\n          let imported;\n          if (specifier.type === \"ExportSpecifier\") {\n            imported = specifier.local;\n          } else if (specifier.type === \"ImportSpecifier\") {\n            imported = specifier.imported;\n          }\n          if (imported !== undefined) {\n            return imported.type === \"Identifier\"\n              ? imported.name !== \"default\"\n              : imported.value !== \"default\";\n          }\n        });\n        if (nonDefaultNamedSpecifier !== undefined) {\n          this.raise(Errors.ImportJSONBindingNotDefault, {\n            at: nonDefaultNamedSpecifier.loc.start,\n          });\n        }\n      }\n    }\n  }\n\n  isPotentialImportPhase(isExport: boolean): boolean {\n    return !isExport && this.isContextual(tt._module);\n  }\n\n  applyImportPhase(\n    node: Undone<N.ImportDeclaration | N.ExportNamedDeclaration>,\n    isExport: boolean,\n    phase: string | null,\n    loc?: Position,\n  ): void {\n    if (isExport) {\n      if (!process.env.IS_PUBLISH) {\n        if (phase === \"module\") {\n          throw new Error(\n            \"Assertion failure: export declarations do not support the 'module' phase.\",\n          );\n        }\n      }\n      return;\n    }\n    if (phase === \"module\") {\n      this.expectPlugin(\"importReflection\", loc);\n      (node as N.ImportDeclaration).module = true;\n    } else if (this.hasPlugin(\"importReflection\")) {\n      (node as N.ImportDeclaration).module = false;\n    }\n  }\n\n  /*\n   * Parse `module` in `import module x fro \"x\"`, disambiguating\n   * `import module from \"x\"` and `import module from from \"x\"`.\n   *\n   * This function might return an identifier representing the `module`\n   * if it eats `module` and then discovers that it was the default import\n   * binding and not the import reflection.\n   *\n   * This function is also used to parse `import type` and `import typeof`\n   * in the TS and Flow plugins.\n   *\n   * Note: the proposal has been updated to use `source` instead of `module`,\n   * but it has not been implemented yet.\n   */\n  parseMaybeImportPhase(\n    node: Undone<N.ImportDeclaration | N.TsImportEqualsDeclaration>,\n    isExport: boolean,\n  ): N.Identifier | null {\n    if (!this.isPotentialImportPhase(isExport)) {\n      this.applyImportPhase(\n        node as Undone<N.ImportDeclaration>,\n        isExport,\n        null,\n      );\n      return null;\n    }\n\n    const phaseIdentifier = this.parseIdentifier(true);\n\n    const { type } = this.state;\n    const isImportPhase = tokenIsKeywordOrIdentifier(type)\n      ? // OK: import <phase> x from \"foo\";\n        // OK: import <phase> from from \"foo\";\n        // NO: import <phase> from \"foo\";\n        // NO: import <phase> from 'foo';\n        // With the module declarations proposals, we will need further disambiguation\n        // for `import module from from;`.\n        type !== tt._from || this.lookaheadCharCode() === charCodes.lowercaseF\n      : // OK: import <phase> { x } from \"foo\";\n        // OK: import <phase> x from \"foo\";\n        // OK: import <phase> * as T from \"foo\";\n        // NO: import <phase> from \"foo\";\n        // OK: import <phase> \"foo\";\n        // The last one is invalid, we will continue parsing and throw\n        // an error later\n        type !== tt.comma;\n\n    if (isImportPhase) {\n      this.resetPreviousIdentifierLeadingComments(phaseIdentifier);\n      this.applyImportPhase(\n        node as Undone<N.ImportDeclaration>,\n        isExport,\n        phaseIdentifier.name,\n        phaseIdentifier.loc.start,\n      );\n      return null;\n    } else {\n      this.applyImportPhase(\n        node as Undone<N.ImportDeclaration>,\n        isExport,\n        null,\n      );\n      // `<phase>` is a default binding, return it to the main import declaration parser\n      return phaseIdentifier;\n    }\n  }\n\n  isPrecedingIdImportPhase(\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    phase: string,\n  ) {\n    const { type } = this.state;\n    return tokenIsIdentifier(type)\n      ? // OK: import <phase> x from \"foo\";\n        // OK: import <phase> from from \"foo\";\n        // NO: import <phase> from \"foo\";\n        // NO: import <phase> from 'foo';\n        // With the module declarations proposals, we will need further disambiguation\n        // for `import module from from;`.\n        type !== tt._from || this.lookaheadCharCode() === charCodes.lowercaseF\n      : // OK: import <phase> { x } from \"foo\";\n        // OK: import <phase> x from \"foo\";\n        // OK: import <phase> * as T from \"foo\";\n        // NO: import <phase> from \"foo\";\n        // OK: import <phase> \"foo\";\n        // The last one is invalid, we will continue parsing and throw\n        // an error later\n        type !== tt.comma;\n  }\n\n  // Parses import declaration.\n  // https://tc39.es/ecma262/#prod-ImportDeclaration\n\n  parseImport(this: Parser, node: Undone<N.ImportDeclaration>): N.AnyImport {\n    if (this.match(tt.string)) {\n      // import '...'\n      return this.parseImportSourceAndAttributes(node);\n    }\n\n    return this.parseImportSpecifiersAndAfter(\n      node,\n      this.parseMaybeImportPhase(node, /* isExport */ false),\n    );\n  }\n\n  parseImportSpecifiersAndAfter(\n    this: Parser,\n    node: Undone<N.ImportDeclaration>,\n    maybeDefaultIdentifier: N.Identifier | null,\n  ): N.AnyImport {\n    node.specifiers = [];\n\n    // check if we have a default import like\n    // import React from \"react\";\n    const hasDefault = this.maybeParseDefaultImportSpecifier(\n      node,\n      maybeDefaultIdentifier,\n    );\n    /* we are checking if we do not have a default import, then it is obvious that we need named imports\n     * import { get } from \"axios\";\n     * but if we do have a default import\n     * we need to check if we have a comma after that and\n     * that is where this `|| this.eat` condition comes into play\n     */\n    const parseNext = !hasDefault || this.eat(tt.comma);\n    // if we do have to parse the next set of specifiers, we first check for star imports\n    // import React, * from \"react\";\n    const hasStar = parseNext && this.maybeParseStarImportSpecifier(node);\n    // now we check if we need to parse the next imports\n    // but only if they are not importing * (everything)\n    if (parseNext && !hasStar) this.parseNamedImportSpecifiers(node);\n    this.expectContextual(tt._from);\n\n    return this.parseImportSourceAndAttributes(node);\n  }\n\n  parseImportSourceAndAttributes(\n    this: Parser,\n    node: Undone<N.ImportDeclaration>,\n  ): N.AnyImport {\n    node.specifiers ??= [];\n    node.source = this.parseImportSource();\n    this.maybeParseImportAttributes(node);\n    this.checkImportReflection(node);\n    this.checkJSONModuleImport(node);\n\n    this.semicolon();\n    return this.finishNode(node, \"ImportDeclaration\");\n  }\n\n  parseImportSource(this: Parser): N.StringLiteral {\n    if (!this.match(tt.string)) this.unexpected();\n    return this.parseExprAtom() as N.StringLiteral;\n  }\n\n  parseImportSpecifierLocal<\n    T extends\n      | N.ImportSpecifier\n      | N.ImportDefaultSpecifier\n      | N.ImportNamespaceSpecifier,\n  >(\n    node: Undone<N.ImportDeclaration>,\n    specifier: Undone<T>,\n    type: T[\"type\"],\n  ): void {\n    specifier.local = this.parseIdentifier();\n    node.specifiers.push(this.finishImportSpecifier(specifier, type));\n  }\n\n  finishImportSpecifier<\n    T extends\n      | N.ImportSpecifier\n      | N.ImportDefaultSpecifier\n      | N.ImportNamespaceSpecifier,\n  >(specifier: Undone<T>, type: T[\"type\"], bindingType = BIND_LEXICAL) {\n    this.checkLVal(specifier.local, {\n      in: { type },\n      binding: bindingType,\n    });\n    return this.finishNode(specifier, type);\n  }\n\n  /**\n   * parse assert entries\n   *\n   * @see {@link https://tc39.es/proposal-import-attributes/#prod-WithEntries WithEntries}\n   */\n  parseImportAttributes(): N.ImportAttribute[] {\n    this.expect(tt.braceL);\n\n    const attrs = [];\n    const attrNames = new Set();\n\n    do {\n      if (this.match(tt.braceR)) {\n        break;\n      }\n\n      const node = this.startNode<N.ImportAttribute>();\n\n      // parse AssertionKey : IdentifierName, StringLiteral\n      const keyName = this.state.value;\n      // check if we already have an entry for an attribute\n      // if a duplicate entry is found, throw an error\n      // for now this logic will come into play only when someone declares `type` twice\n      if (attrNames.has(keyName)) {\n        this.raise(Errors.ModuleAttributesWithDuplicateKeys, {\n          at: this.state.startLoc,\n          key: keyName,\n        });\n      }\n      attrNames.add(keyName);\n      if (this.match(tt.string)) {\n        node.key = this.parseStringLiteral(keyName);\n      } else {\n        node.key = this.parseIdentifier(true);\n      }\n      this.expect(tt.colon);\n\n      if (!this.match(tt.string)) {\n        throw this.raise(Errors.ModuleAttributeInvalidValue, {\n          at: this.state.startLoc,\n        });\n      }\n      node.value = this.parseStringLiteral(this.state.value);\n      attrs.push(this.finishNode(node, \"ImportAttribute\"));\n    } while (this.eat(tt.comma));\n\n    this.expect(tt.braceR);\n\n    return attrs;\n  }\n\n  /**\n   * parse module attributes\n   * @deprecated It will be removed in Babel 8\n   */\n  parseModuleAttributes() {\n    const attrs: N.ImportAttribute[] = [];\n    const attributes = new Set();\n    do {\n      const node = this.startNode<N.ImportAttribute>();\n      node.key = this.parseIdentifier(true);\n\n      if (node.key.name !== \"type\") {\n        this.raise(Errors.ModuleAttributeDifferentFromType, {\n          at: node.key,\n        });\n      }\n\n      if (attributes.has(node.key.name)) {\n        this.raise(Errors.ModuleAttributesWithDuplicateKeys, {\n          at: node.key,\n          key: node.key.name,\n        });\n      }\n      attributes.add(node.key.name);\n      this.expect(tt.colon);\n      if (!this.match(tt.string)) {\n        throw this.raise(Errors.ModuleAttributeInvalidValue, {\n          at: this.state.startLoc,\n        });\n      }\n      node.value = this.parseStringLiteral(this.state.value);\n      attrs.push(this.finishNode(node, \"ImportAttribute\"));\n    } while (this.eat(tt.comma));\n\n    return attrs;\n  }\n\n  maybeParseImportAttributes(\n    node: Undone<N.ImportDeclaration | N.ExportNamedDeclaration>,\n  ) {\n    let attributes: N.ImportAttribute[];\n    let useWith = false;\n\n    // https://tc39.es/proposal-import-attributes/#prod-WithClause\n    if (this.match(tt._with)) {\n      if (\n        this.hasPrecedingLineBreak() &&\n        this.lookaheadCharCode() === charCodes.leftParenthesis\n      ) {\n        // This will be parsed as a with statement, and we will throw a\n        // better error about it not being supported in strict mode.\n        return;\n      }\n\n      this.next(); // eat `with`\n\n      if (!process.env.BABEL_8_BREAKING) {\n        if (this.hasPlugin(\"moduleAttributes\")) {\n          attributes = this.parseModuleAttributes();\n        } else {\n          this.expectImportAttributesPlugin();\n          attributes = this.parseImportAttributes();\n        }\n      } else {\n        this.expectImportAttributesPlugin();\n        attributes = this.parseImportAttributes();\n      }\n      useWith = true;\n    } else if (this.isContextual(tt._assert) && !this.hasPrecedingLineBreak()) {\n      if (this.hasPlugin(\"importAttributes\")) {\n        if (\n          this.getPluginOption(\"importAttributes\", \"deprecatedAssertSyntax\") !==\n          true\n        ) {\n          this.raise(Errors.ImportAttributesUseAssert, {\n            at: this.state.startLoc,\n          });\n        }\n        this.addExtra(node, \"deprecatedAssertSyntax\", true);\n      } else {\n        this.expectOnePlugin([\"importAttributes\", \"importAssertions\"]);\n      }\n      this.next(); // eat `assert`\n      attributes = this.parseImportAttributes();\n    } else if (\n      this.hasPlugin(\"importAttributes\") ||\n      this.hasPlugin(\"importAssertions\")\n    ) {\n      attributes = [];\n    } else if (!process.env.BABEL_8_BREAKING) {\n      if (this.hasPlugin(\"moduleAttributes\")) {\n        attributes = [];\n      } else return;\n    } else return;\n\n    if (!useWith && this.hasPlugin(\"importAssertions\")) {\n      node.assertions = attributes;\n    } else {\n      node.attributes = attributes;\n    }\n  }\n\n  maybeParseDefaultImportSpecifier(\n    node: Undone<N.ImportDeclaration>,\n    maybeDefaultIdentifier: N.Identifier | null,\n  ): boolean {\n    // import defaultObj, { x, y as z } from '...'\n    if (maybeDefaultIdentifier) {\n      const specifier = this.startNodeAtNode<N.ImportDefaultSpecifier>(\n        maybeDefaultIdentifier,\n      );\n      specifier.local = maybeDefaultIdentifier;\n      node.specifiers.push(\n        this.finishImportSpecifier(specifier, \"ImportDefaultSpecifier\"),\n      );\n      return true;\n    } else if (\n      // We allow keywords, and parseImportSpecifierLocal will report a recoverable error\n      tokenIsKeywordOrIdentifier(this.state.type)\n    ) {\n      this.parseImportSpecifierLocal(\n        node,\n        this.startNode<N.ImportDefaultSpecifier>(),\n        \"ImportDefaultSpecifier\",\n      );\n      return true;\n    }\n    return false;\n  }\n\n  maybeParseStarImportSpecifier(node: Undone<N.ImportDeclaration>): boolean {\n    if (this.match(tt.star)) {\n      const specifier = this.startNode<N.ImportNamespaceSpecifier>();\n      this.next();\n      this.expectContextual(tt._as);\n\n      this.parseImportSpecifierLocal(\n        node,\n        specifier,\n        \"ImportNamespaceSpecifier\",\n      );\n      return true;\n    }\n    return false;\n  }\n\n  parseNamedImportSpecifiers(node: Undone<N.ImportDeclaration>) {\n    let first = true;\n    this.expect(tt.braceL);\n    while (!this.eat(tt.braceR)) {\n      if (first) {\n        first = false;\n      } else {\n        // Detect an attempt to deep destructure\n        if (this.eat(tt.colon)) {\n          throw this.raise(Errors.DestructureNamedImport, {\n            at: this.state.startLoc,\n          });\n        }\n\n        this.expect(tt.comma);\n        if (this.eat(tt.braceR)) break;\n      }\n\n      const specifier = this.startNode<N.ImportSpecifier>();\n      const importedIsString = this.match(tt.string);\n      const isMaybeTypeOnly = this.isContextual(tt._type);\n      specifier.imported = this.parseModuleExportName();\n      const importSpecifier = this.parseImportSpecifier(\n        specifier,\n        importedIsString,\n        node.importKind === \"type\" || node.importKind === \"typeof\",\n        isMaybeTypeOnly,\n        undefined,\n      );\n      node.specifiers.push(importSpecifier);\n    }\n  }\n\n  // https://tc39.es/ecma262/#prod-ImportSpecifier\n  parseImportSpecifier(\n    specifier: Undone<N.ImportSpecifier>,\n    importedIsString: boolean,\n    /* eslint-disable @typescript-eslint/no-unused-vars -- used in TypeScript and Flow parser */\n    isInTypeOnlyImport: boolean,\n    isMaybeTypeOnly: boolean,\n    bindingType: BindingTypes | undefined,\n    /* eslint-enable @typescript-eslint/no-unused-vars */\n  ): N.ImportSpecifier {\n    if (this.eatContextual(tt._as)) {\n      specifier.local = this.parseIdentifier();\n    } else {\n      const { imported } = specifier;\n      if (importedIsString) {\n        throw this.raise(Errors.ImportBindingIsString, {\n          at: specifier,\n          importName: (imported as N.StringLiteral).value,\n        });\n      }\n      this.checkReservedWord(\n        (imported as N.Identifier).name,\n        specifier.loc.start,\n        true,\n        true,\n      );\n      if (!specifier.local) {\n        specifier.local = cloneIdentifier(imported);\n      }\n    }\n    return this.finishImportSpecifier(\n      specifier,\n      \"ImportSpecifier\",\n      bindingType,\n    );\n  }\n\n  // This is used in flow and typescript plugin\n  // Determine whether a parameter is a this param\n  isThisParam(\n    param: N.Pattern | N.Identifier | N.TSParameterProperty,\n  ): boolean {\n    return param.type === \"Identifier\" && param.name === \"this\";\n  }\n}\n","import type { Options } from \"../options\";\nimport type * as N from \"../types\";\nimport type { PluginList } from \"../plugin-utils\";\nimport { getOptions } from \"../options\";\nimport StatementParser from \"./statement\";\nimport ScopeHandler from \"../util/scope\";\n\nexport type PluginsMap = Map<\n  string,\n  {\n    [x: string]: any;\n  }\n>;\n\nexport default class Parser extends StatementParser {\n  // Forward-declaration so typescript plugin can override jsx plugin\n  // todo(flow->ts) - this probably can be removed\n  // abstract jsxParseOpeningElementAfterName(\n  //   node: N.JSXOpeningElement,\n  // ): N.JSXOpeningElement;\n\n  constructor(options: Options | undefined | null, input: string) {\n    options = getOptions(options);\n    super(options, input);\n\n    this.options = options;\n    this.initializeScopes();\n    this.plugins = pluginsMap(this.options.plugins);\n    this.filename = options.sourceFilename;\n  }\n\n  // This can be overwritten, for example, by the TypeScript plugin.\n  getScopeHandler(): {\n    new (...args: any): ScopeHandler;\n  } {\n    return ScopeHandler;\n  }\n\n  parse(): N.File {\n    this.enterInitialScopes();\n    const file = this.startNode() as N.File;\n    const program = this.startNode() as N.Program;\n    this.nextToken();\n    file.errors = null;\n    this.parseTopLevel(file, program);\n    file.errors = this.state.errors;\n    return file;\n  }\n}\n\nfunction pluginsMap(plugins: PluginList): PluginsMap {\n  const pluginMap: PluginsMap = new Map();\n  for (const plugin of plugins) {\n    const [name, options] = Array.isArray(plugin) ? plugin : [plugin, {}];\n    if (!pluginMap.has(name)) pluginMap.set(name, options || {});\n  }\n  return pluginMap;\n}\n","import type { Options } from \"./options\";\nimport {\n  hasPlugin,\n  validatePlugins,\n  mixinPluginNames,\n  mixinPlugins,\n  type PluginList,\n} from \"./plugin-utils\";\nimport type {\n  PluginConfig as ParserPlugin,\n  FlowPluginOptions,\n  RecordAndTuplePluginOptions,\n  PipelineOperatorPluginOptions,\n} from \"./typings\";\nimport Parser from \"./parser\";\n\nimport type { ExportedTokenType } from \"./tokenizer/types\";\nimport {\n  getExportedToken,\n  tt as internalTokenTypes,\n  type InternalTokenTypes,\n} from \"./tokenizer/types\";\nimport \"./tokenizer/context\";\n\nimport type { Expression, File } from \"./types\";\n\nexport function parse(input: string, options?: Options): File {\n  if (options?.sourceType === \"unambiguous\") {\n    options = {\n      ...options,\n    };\n    try {\n      options.sourceType = \"module\";\n      const parser = getParser(options, input);\n      const ast = parser.parse();\n\n      if (parser.sawUnambiguousESM) {\n        return ast;\n      }\n\n      if (parser.ambiguousScriptDifferentAst) {\n        // Top level await introduces code which can be both a valid script and\n        // a valid module, but which produces different ASTs:\n        //    await\n        //    0\n        // can be parsed either as an AwaitExpression, or as two ExpressionStatements.\n        try {\n          options.sourceType = \"script\";\n          return getParser(options, input).parse();\n        } catch {}\n      } else {\n        // This is both a valid module and a valid script, but\n        // we parse it as a script by default\n        ast.program.sourceType = \"script\";\n      }\n\n      return ast;\n    } catch (moduleError) {\n      try {\n        options.sourceType = \"script\";\n        return getParser(options, input).parse();\n      } catch {}\n\n      throw moduleError;\n    }\n  } else {\n    return getParser(options, input).parse();\n  }\n}\n\nexport function parseExpression(input: string, options?: Options): Expression {\n  const parser = getParser(options, input);\n  if (parser.options.strictMode) {\n    parser.state.strict = true;\n  }\n  return parser.getExpression();\n}\n\nfunction generateExportedTokenTypes(\n  internalTokenTypes: InternalTokenTypes,\n): Record<string, ExportedTokenType> {\n  const tokenTypes: Record<string, ExportedTokenType> = {};\n  for (const typeName of Object.keys(\n    internalTokenTypes,\n  ) as (keyof InternalTokenTypes)[]) {\n    tokenTypes[typeName] = getExportedToken(internalTokenTypes[typeName]);\n  }\n  return tokenTypes;\n}\n\nexport const tokTypes = generateExportedTokenTypes(internalTokenTypes);\n\nfunction getParser(options: Options | undefined | null, input: string): Parser {\n  let cls = Parser;\n  if (options?.plugins) {\n    validatePlugins(options.plugins);\n    cls = getParserClass(options.plugins);\n  }\n\n  return new cls(options, input);\n}\n\nconst parserClassCache: { [key: string]: { new (...args: any): Parser } } = {};\n\n/** Get a Parser class with plugins applied. */\nfunction getParserClass(pluginsFromOptions: PluginList): {\n  new (...args: any): Parser;\n} {\n  const pluginList = mixinPluginNames.filter(name =>\n    hasPlugin(pluginsFromOptions, name),\n  );\n\n  const key = pluginList.join(\"/\");\n  let cls = parserClassCache[key];\n  if (!cls) {\n    cls = Parser;\n    for (const plugin of pluginList) {\n      // @ts-expect-error todo(flow->ts)\n      cls = mixinPlugins[plugin](cls);\n    }\n    parserClassCache[key] = cls;\n  }\n  return cls;\n}\n\nexport type {\n  FlowPluginOptions,\n  ParserPlugin,\n  PipelineOperatorPluginOptions,\n  RecordAndTuplePluginOptions,\n};\nexport type ParserOptions = Partial<Options>;\n"],"names":["Position","constructor","line","col","index","column","SourceLocation","start","end","filename","identifierName","createPositionWithColumnOffset","position","columnOffset","ParseErrorCode","SyntaxError","SourceTypeModuleError","reflect","keys","last","length","get","reduce","object","key","set","value","item","i","instantiate","properties","descriptors","Object","map","filter","descriptor","enumerable","assign","split","instance","defineProperty","configurable","ModuleErrors","ImportMetaOutsideModule","message","code","ImportOutsideModule","NodeDescriptions","ArrayPattern","AssignmentExpression","AssignmentPattern","ArrowFunctionExpression","ConditionalExpression","CatchClause","ForOfStatement","ForInStatement","ForStatement","FormalParameters","Identifier","ImportSpecifier","ImportDefaultSpecifier","ImportNamespaceSpecifier","ObjectPattern","ParenthesizedExpression","RestElement","UpdateExpression","true","false","VariableDeclarator","YieldExpression","toNodeDescription","type","prefix","String","StandardErrors","AccessorIsGenerator","kind","ArgumentsInClass","AsyncFunctionInSingleStatementContext","AwaitBindingIdentifier","AwaitBindingIdentifierInStaticBlock","AwaitExpressionFormalParameter","AwaitUsingNotInAsyncContext","AwaitNotInAsyncContext","AwaitNotInAsyncFunction","BadGetterArity","BadSetterArity","BadSetterRestParameter","ConstructorClassField","ConstructorClassPrivateField","ConstructorIsAccessor","ConstructorIsAsync","ConstructorIsGenerator","DeclarationMissingInitializer","DecoratorArgumentsOutsideParentheses","DecoratorBeforeExport","DecoratorsBeforeAfterExport","DecoratorConstructor","DecoratorExportClass","DecoratorSemicolon","DecoratorStaticBlock","DeletePrivateField","DestructureNamedImport","DuplicateConstructor","DuplicateDefaultExport","DuplicateExport","exportName","DuplicateProto","DuplicateRegExpFlags","ElementAfterRest","EscapedCharNotAnIdentifier","ExportBindingIsString","localName","ExportDefaultFromAsIdentifier","ForInOfLoopInitializer","ForInUsing","ForOfAsync","ForOfLet","GeneratorInSingleStatementContext","IllegalBreakContinue","IllegalLanguageModeDirective","IllegalReturn","ImportAttributesUseAssert","ImportBindingIsString","importName","ImportCallArgumentTrailingComma","ImportCallArity","maxArgumentCount","ImportCallNotNewExpression","ImportCallSpreadArgument","ImportJSONBindingNotDefault","ImportReflectionHasAssertion","ImportReflectionNotBinding","IncompatibleRegExpUVFlags","InvalidBigIntLiteral","InvalidCodePoint","InvalidCoverInitializedName","InvalidDecimal","InvalidDigit","radix","InvalidEscapeSequence","InvalidEscapeSequenceTemplate","InvalidEscapedReservedWord","reservedWord","InvalidIdentifier","InvalidLhs","ancestor","InvalidLhsBinding","InvalidNumber","InvalidOrMissingExponent","InvalidOrUnexpectedToken","unexpected","InvalidParenthesizedAssignment","InvalidPrivateFieldResolution","InvalidPropertyBindingPattern","InvalidRecordProperty","InvalidRestAssignmentPattern","LabelRedeclaration","labelName","LetInLexicalBinding","LineTerminatorBeforeArrow","MalformedRegExpFlags","MissingClassName","MissingEqInAssignment","MissingSemicolon","MissingPlugin","missingPlugin","name","JSON","stringify","join","MissingOneOfPlugins","MissingUnicodeEscape","MixingCoalesceWithLogical","ModuleAttributeDifferentFromType","ModuleAttributeInvalidValue","ModuleAttributesWithDuplicateKeys","ModuleExportNameHasLoneSurrogate","surrogateCharCode","toString","ModuleExportUndefined","MultipleDefaultsInSwitch","NewlineAfterThrow","NoCatchOrFinally","NumberIdentifier","NumericSeparatorInEscapeSequence","ObsoleteAwaitStar","OptionalChainingNoNew","OptionalChainingNoTemplate","OverrideOnConstructor","ParamDupe","PatternHasAccessor","PatternHasMethod","PrivateInExpectedIn","PrivateNameRedeclaration","RecordExpressionBarIncorrectEndSyntaxType","RecordExpressionBarIncorrectStartSyntaxType","RecordExpressionHashIncorrectStartSyntaxType","RecordNoProto","RestTrailingComma","SloppyFunction","SloppyFunctionAnnexB","StaticPrototype","SuperNotAllowed","SuperPrivateField","TrailingDecorator","TupleExpressionBarIncorrectEndSyntaxType","TupleExpressionBarIncorrectStartSyntaxType","TupleExpressionHashIncorrectStartSyntaxType","UnexpectedArgumentPlaceholder","UnexpectedAwaitAfterPipelineBody","UnexpectedDigitAfterHash","UnexpectedImportExport","UnexpectedKeyword","keyword","UnexpectedLeadingDecorator","UnexpectedLexicalDeclaration","UnexpectedNewTarget","UnexpectedNumericSeparator","UnexpectedPrivateField","UnexpectedReservedWord","UnexpectedSuper","UnexpectedToken","expected","UnexpectedTokenUnaryExponentiation","UnexpectedUsingDeclaration","UnsupportedBind","UnsupportedDecoratorExport","UnsupportedDefaultExport","UnsupportedImport","UnsupportedMetaProperty","target","onlyValidPropertyName","UnsupportedParameterDecorator","UnsupportedPropertyDecorator","UnsupportedSuper","UnterminatedComment","UnterminatedRegExp","UnterminatedString","UnterminatedTemplate","UsingDeclarationHasBindingPattern","VarRedeclaration","YieldBindingIdentifier","YieldInParameter","ZeroDigitNumericSeparator","StrictModeErrors","StrictDelete","StrictEvalArguments","referenceName","StrictEvalArgumentsBinding","bindingName","StrictFunction","StrictNumericEscape","StrictOctalLiteral","StrictWith","UnparenthesizedPipeBodyDescriptions","Set","PipelineOperatorErrors","PipeBodyIsTighter","PipeTopicRequiresHackPipes","PipeTopicUnbound","PipeTopicUnconfiguredToken","token","PipeTopicUnused","PipeUnparenthesizedBody","PipelineBodyNoArrow","PipelineBodySequenceExpression","PipelineHeadSequenceExpression","PipelineTopicUnused","PrimaryTopicNotAllowed","PrimaryTopicRequiresSmartPipeline","toParseErrorConstructor","_ref","toMessage","_objectWithoutPropertiesLoose","_excluded","loc","details","clone","overrides","pos","ParseErrorEnum","argument","syntaxPlugin","Array","isArray","parseErrorTemplates","ParseErrorConstructors","reasonCode","template","_ref2","rest","_excluded2","Errors","toUnenumerable","toESTreeLocation","node","estree","superClass","ESTreeParserMixin","parse","file","options","tokens","parseRegExpLiteral","pattern","flags","regex","RegExp","e","estreeParseLiteral","parseBigIntLiteral","bigInt","BigInt","_unused","bigint","parseDecimalLiteral","decimal","parseLiteral","parseStringLiteral","parseNumericLiteral","parseNullLiteral","parseBooleanLiteral","directiveToStmt","directive","expression","raw","extra","expressionValue","stmt","rawValue","initFunction","isAsync","checkDeclaration","isObjectProperty","getObjectOrClassMethodParams","method","params","isValidDirective","_stmt$expression$extr","parenthesized","parseBlockBody","allowDirectives","topLevel","afterBlockParse","directiveStatements","directives","d","body","concat","pushClassMethod","classBody","isGenerator","isConstructor","allowsDirectSuper","parseMethod","typeParameters","push","parsePrivateName","getPluginOption","convertPrivateNameToPrivateIdentifier","getPrivateNameSV","id","isPrivateName","parseFunctionBody","allowExpression","isMethod","allowDirectSuper","inClassScope","funcNode","startNode","computed","finishNode","parseClassProperty","args","propertyNode","parseClassPrivateProperty","parseObjectMethod","prop","isPattern","isAccessor","shorthand","parseObjectProperty","startLoc","refExpressionErrors","isValidLVal","isUnparenthesizedInAssign","binding","isAssignable","isBinding","toAssignable","isLHS","classScope","usePrivateName","toAssignableObjectExpressionProp","isLast","raise","at","finishCallExpression","unfinished","optional","callee","source","arguments","hasPlugin","_node$arguments$","attributes","toReferencedArguments","parseExport","decorators","exportStartLoc","state","lastTokStartLoc","exported","specifiers","_declaration$decorato","declaration","resetStartLocation","parseSubscript","base","noCalls","optionalChainMember","substring","stop","chain","startNodeAtNode","hasPropertyAsPrivateName","isObjectMethod","finishNodeAt","endLoc","resetEndLocation","lastTokEndLoc","TokContext","preserveSpace","types","brace","j_oTag","j_cTag","j_expr","beforeExpr","startsExpr","isLoop","isAssign","postfix","ExportedTokenType","label","conf","rightAssociative","binop","updateContext","keywords","Map","createKeyword","createToken","createBinop","tokenTypeCounter","tokenTypes","tokenLabels","tokenBinops","tokenBeforeExprs","tokenStartsExprs","tokenPrefixes","_options$binop","_options$beforeExpr","_options$startsExpr","_options$prefix","createKeywordLike","_options$binop2","_options$beforeExpr2","_options$startsExpr2","_options$prefix2","tt","bracketL","bracketHashL","bracketBarL","bracketR","bracketBarR","braceL","braceBarL","braceHashL","braceR","braceBarR","parenL","parenR","comma","semi","colon","doubleColon","dot","question","questionDot","arrow","ellipsis","backQuote","dollarBraceL","templateTail","templateNonTail","hash","interpreterDirective","eq","slashAssign","xorAssign","moduloAssign","incDec","bang","tilde","doubleCaret","doubleAt","pipeline","nullishCoalescing","logicalOR","logicalAND","bitwiseOR","bitwiseXOR","bitwiseAND","equality","lt","gt","relational","bitShift","bitShiftL","bitShiftR","plusMin","modulo","star","slash","exponent","_in","_instanceof","_break","_case","_catch","_continue","_debugger","_default","_else","_finally","_function","_if","_return","_switch","_throw","_try","_var","_const","_with","_new","_this","_super","_class","_extends","_export","_import","_null","_true","_false","_typeof","_void","_delete","_do","_for","_while","_as","_assert","_async","_await","_from","_get","_let","_meta","_of","_sent","_set","_static","_using","_yield","_asserts","_checks","_exports","_global","_implements","_intrinsic","_infer","_is","_mixins","_proto","_require","_satisfies","_keyof","_readonly","_unique","_abstract","_declare","_enum","_module","_namespace","_interface","_type","_opaque","string","num","regexp","privateName","eof","jsxName","jsxText","jsxTagStart","jsxTagEnd","placeholder","tokenIsIdentifier","tokenKeywordOrIdentifierIsKeyword","tokenIsKeywordOrIdentifier","tokenIsLiteralPropertyName","tokenComesBeforeExpression","tokenCanStartExpression","tokenIsAssignment","tokenIsFlowInterfaceOrTypeOrOpaque","tokenIsLoop","tokenIsKeyword","tokenIsOperator","tokenIsPostfix","tokenIsPrefix","tokenIsTSTypeOperator","tokenIsTSDeclarationStart","tokenLabelName","tokenOperatorPrecedence","tokenIsRightAssociative","tokenIsTemplate","getExportedToken","context","pop","tc","nonASCIIidentifierStartChars","nonASCIIidentifierChars","nonASCIIidentifierStart","nonASCIIidentifier","astralIdentifierStartCodes","astralIdentifierCodes","isInAstralSet","isIdentifierStart","test","fromCharCode","isIdentifierChar","reservedWords","strict","strictBind","reservedWordsStrictSet","reservedWordsStrictBindSet","isReservedWord","word","inModule","isStrictReservedWord","has","isStrictBindOnlyReservedWord","isStrictBindReservedWord","isKeyword","isIteratorStart","current","next","next2","reservedWordLikeSet","canBeReservedWord","SCOPE_OTHER","SCOPE_PROGRAM","SCOPE_FUNCTION","SCOPE_ARROW","SCOPE_SIMPLE_CATCH","SCOPE_SUPER","SCOPE_DIRECT_SUPER","SCOPE_CLASS","SCOPE_STATIC_BLOCK","SCOPE_TS_MODULE","SCOPE_VAR","BIND_KIND_VALUE","BIND_KIND_TYPE","BIND_SCOPE_VAR","BIND_SCOPE_LEXICAL","BIND_SCOPE_FUNCTION","BIND_FLAGS_NONE","BIND_FLAGS_CLASS","BIND_FLAGS_TS_ENUM","BIND_FLAGS_TS_CONST_ENUM","BIND_FLAGS_TS_EXPORT_ONLY","BIND_FLAGS_FLOW_DECLARE_FN","BIND_FLAGS_TS_IMPORT","BIND_FLAGS_NO_LET_IN_LEXICAL","BIND_CLASS","BIND_LEXICAL","BIND_CATCH_PARAM","BIND_VAR","BIND_FUNCTION","BIND_TS_INTERFACE","BIND_TS_TYPE","BIND_TS_ENUM","BIND_TS_AMBIENT","BIND_NONE","BIND_OUTSIDE","BIND_TS_CONST_ENUM","BIND_TS_NAMESPACE","BIND_TS_TYPE_IMPORT","BIND_FLOW_DECLARE_FN","CLASS_ELEMENT_FLAG_STATIC","CLASS_ELEMENT_KIND_GETTER","CLASS_ELEMENT_KIND_SETTER","CLASS_ELEMENT_KIND_ACCESSOR","CLASS_ELEMENT_STATIC_GETTER","CLASS_ELEMENT_STATIC_SETTER","CLASS_ELEMENT_INSTANCE_GETTER","CLASS_ELEMENT_INSTANCE_SETTER","CLASS_ELEMENT_OTHER","Scope","var","lexical","functions","ScopeHandler","parser","scopeStack","undefinedExports","inTopLevel","currentScope","inFunction","currentVarScopeFlags","allowSuper","currentThisScopeFlags","inClass","inClassAndNotInNonArrowFunction","inStaticBlock","inNonArrowFunction","treatFunctionsAsVar","treatFunctionsAsVarInScope","createScope","enter","exit","scope","declareName","bindingType","checkRedeclarationInScope","add","maybeExportDefined","delete","isRedeclaredInScope","values","checkLocalExport","topLevelScope","FlowScope","declareFunctions","FlowScopeHandler","BaseParser","sawUnambiguousESM","ambiguousScriptDifferentAst","pluginConfig","plugins","pluginName","pluginOptions","actualOptions","plugin","_this$plugins$get","setTrailingComments","comments","trailingComments","undefined","unshift","setLeadingComments","leadingComments","setInnerComments","innerComments","adjustInnerComments","elements","commentWS","lastElement","CommentsParser","addComment","comment","processComment","commentStack","commentStackLength","lastCommentWS","leadingNode","nodeStart","commentEnd","containingNode","finalizeComment","splice","trailingNode","commentStart","input","charCodeAt","finalizeRemainingComments","resetPreviousNodeTrailingComments","resetPreviousIdentifierLeadingComments","takeSurroundingComments","lineBreak","lineBreakG","isNewLine","skipWhiteSpace","skipWhiteSpaceInLine","skipWhiteSpaceToLineBreak","isWhitespace","State","curLine","lineStart","errors","potentialArrowAt","noArrowAt","noArrowParamsConversionAt","maybeInArrowParameters","inType","noAnonFunctionType","hasFlowComment","isAmbientContext","inAbstractClass","inDisallowConditionalTypesContext","topicContext","maxNumOfResolvableTopics","maxTopicIndex","soloAwait","inFSharpPipelineDirectBody","labels","lastTokStart","ct","canStartJSXElement","containsEsc","firstInvalidTemplateEscapePos","strictErrors","tokensLength","init","strictMode","sourceType","startLine","startColumn","curPosition","skipArrays","val","slice","isDigit","forbiddenNumericSeparatorSiblings","decBinOct","hex","isAllowedNumericSeparatorSibling","bin","ch","oct","dec","readStringContents","initialPos","initialLineStart","initialCurLine","out","firstInvalidLoc","chunkStart","unterminated","isStringEnd","res","readEscapedChar","str","containsInvalid","inTemplate","throwOnInvalid","readHexChar","readCodePoint","fromCodePoint","strictNumericEscape","startPos","match","octalStr","octal","parseInt","len","forceLen","n","readInt","invalidEscapeSequence","allowNumSeparator","bailOnError","forbiddenSiblings","isAllowedSibling","invalid","total","Infinity","prev","numericSeparatorInEscapeSequence","Number","isNaN","unexpectedNumericSeparator","_isDigit","invalidDigit","indexOf","invalidCodePoint","buildPosition","VALID_REGEX_FLAGS","Token","Tokenizer","isLookahead","errorHandlers_readInt","errorRecovery","errorBuilder","errorHandlers_readCodePoint","errorHandlers_readStringContents_string","recordStrictModeErrors","errorHandlers_readStringContents_template","pushToken","checkKeywordEscapes","nextToken","eat","createLookaheadState","curContext","lookahead","old","curr","nextTokenStart","nextTokenStartSince","lastIndex","lookaheadCharCode","nextTokenInLineStart","nextTokenInLineStartSince","lookaheadInLineCharCode","codePointAtPos","cp","trail","setStrict","forEach","toParseError","clear","skipSpace","finishToken","getTokenFromCode","skipBlockComment","skipLineComment","startSkip","spaceStart","loop","attachComment","annexB","commentWhitespace","prevType","replaceToken","readToken_numberSign","readToken_interpreter","nextPos","expectPlugin","readWord1","finishOp","readToken_dot","readNumber","readToken_slash","readToken_mult_modulo","width","readToken_pipe_amp","readToken_caret","proposal","topicToken","lookaheadCh","codePointAt","readToken_atSign","readToken_plus_min","readToken_lt","readToken_gt","size","readToken_eq_excl","readToken_question","readTemplateToken","readRadixNumber","readString","readWord","readRegexp","escaped","content","mods","char","includes","isBigInt","replace","startsWithDot","isFloat","isDecimal","hasExponent","isOctal","hasLeadingZero","integer","underscorePos","parseFloat","quote","readTemplateContinuation","opening","firstCode","escStart","identifierCheck","esc","keywordTypes","raiseProperties","error","raiseOverwrite","expectOnePlugin","pluginNames","some","ClassScope","privateNames","loneAccessors","undefinedPrivateNames","ClassScopeHandler","stack","oldClassScope","from","declarePrivateName","elementType","redefined","accessor","oldStatic","newStatic","oldKind","newKind","kExpression","kMaybeArrowParameterDeclaration","kMaybeAsyncArrowParameterDeclaration","kParameterDeclaration","ExpressionScope","canBeArrowParameterDeclaration","isCertainlyParameterDeclaration","ArrowHeadParsingScope","declarationErrors","recordDeclarationError","ParsingErrorClass","clearDeclarationError","iterateErrors","iterator","ExpressionScopeHandler","recordParameterInitializerError","origin","recordArrowParameterBindingError","recordAsyncArrowParametersError","validateAsPattern","newParameterDeclarationScope","newArrowHeadScope","newAsyncArrowScope","newExpressionScope","PARAM","PARAM_YIELD","PARAM_AWAIT","PARAM_RETURN","PARAM_IN","ProductionParameterHandler","stacks","currentFlags","hasAwait","hasYield","hasReturn","hasIn","functionFlags","UtilParser","addExtra","isContextual","isUnparsedContextual","nameStart","nameEnd","nextCh","isLookaheadContextual","eatContextual","expectContextual","canInsertSemicolon","hasPrecedingLineBreak","hasFollowingLineBreak","isLineTerminator","semicolon","allowAsi","expect","tryParse","fn","oldState","abortSignal","failState","thrown","aborted","checkExpressionErrors","andThrow","shorthandAssignLoc","doubleProtoLoc","privateKeyLoc","optionalParametersLoc","hasErrors","isLiteralPropertyName","property","initializeScopes","oldLabels","oldExportedIdentifiers","exportedIdentifiers","oldInModule","oldScope","getScopeHandler","oldProdParam","prodParam","oldExpressionScope","expressionScope","enterInitialScopes","paramFlags","checkDestructuringPrivate","ExpressionErrors","Node","ranges","range","NodePrototype","prototype","__clone","newNode","clonePlaceholder","cloneIdentifier","cloned","create","expectedNode","cloneStringLiteral","NodeUtils","startNodeAt","resetStartLocationFromNode","locationNode","reservedTypes","FlowErrors","AmbiguousConditionalArrow","AmbiguousDeclareModuleKind","AssignReservedType","reservedType","DeclareClassElement","DeclareClassFieldInitializer","DuplicateDeclareModuleExports","EnumBooleanMemberNotInitialized","memberName","enumName","EnumDuplicateMemberName","EnumInconsistentMemberValues","EnumInvalidExplicitType","invalidEnumType","EnumInvalidExplicitTypeUnknownSupplied","EnumInvalidMemberInitializerPrimaryType","explicitType","EnumInvalidMemberInitializerSymbolType","EnumInvalidMemberInitializerUnknownType","EnumInvalidMemberName","suggestion","EnumNumberMemberNotInitialized","EnumStringMemberInconsistentlyInitailized","GetterMayNotHaveThisParam","ImportReflectionHasImportType","ImportTypeShorthandOnlyInPureImport","InexactInsideExact","InexactInsideNonObject","InexactVariance","InvalidNonTypeImportInDeclareModule","MissingTypeParamDefault","NestedDeclareModule","NestedFlowComment","PatternIsOptional","SetterMayNotHaveThisParam","SpreadVariance","ThisParamAnnotationRequired","ThisParamBannedInConstructor","ThisParamMayNotBeOptional","ThisParamMustBeFirst","ThisParamNoDefault","TypeBeforeInitializer","TypeCastInPattern","UnexpectedExplicitInexactInObject","UnexpectedReservedType","UnexpectedReservedUnderscore","UnexpectedSpaceBetweenModuloChecks","UnexpectedSpreadType","UnexpectedSubtractionOperand","UnexpectedTokenAfterTypeParameter","UnexpectedTypeParameterBeforeAsyncArrowFunction","UnsupportedDeclareExportKind","unsupportedExportKind","UnsupportedStatementInDeclareModule","UnterminatedFlowComment","isEsModuleType","bodyElement","hasTypeImportKind","importKind","exportSuggestions","const","let","interface","partition","list","list1","list2","FLOW_PRAGMA_REGEX","flow","FlowParserMixin","flowPragma","shouldParseTypes","shouldParseEnums","matches","exec","Error","flowParseTypeInitialiser","tok","oldInType","flowParseType","flowParsePredicate","moduloLoc","parseExpression","flowParseTypeAndPredicateInitialiser","predicate","flowParseDeclareClass","flowParseInterfaceish","flowParseDeclareFunction","parseIdentifier","typeNode","typeContainer","flowParseTypeParameterDeclaration","tmp","flowParseFunctionTypeParams","this","returnType","typeAnnotation","flowParseDeclare","insideModule","flowParseDeclareVariable","flowParseDeclareModuleExports","flowParseDeclareModule","flowParseDeclareTypeAlias","flowParseDeclareOpaqueType","flowParseDeclareInterface","flowParseDeclareExportDeclaration","flowParseTypeAnnotatableIdentifier","parseExprAtom","bodyNode","parseImport","hasModuleExport","default","isLet","exportKind","flowParseTypeAnnotation","finished","flowParseTypeAlias","flowParseOpaqueType","isClass","flowParseRestrictedIdentifier","extends","flowParseInterfaceExtends","implements","mixins","flowParseObjectType","allowStatic","allowExact","allowSpread","allowProto","allowInexact","flowParseQualifiedTypeIdentifier","flowParseTypeParameterInstantiation","flowParseInterface","checkNotUnderscore","checkReservedType","liberal","right","declare","supertype","impltype","flowParseTypeParameter","requireDefault","nodeStartLoc","variance","flowParseVariance","ident","bound","defaultRequired","typeParameter","oldNoAnonFunctionType","flowParseTypeParameterInstantiationCallOrNew","flowParseTypeOrImplicitInstantiation","flowParseInterfaceType","flowParseObjectPropertyKey","flowParseObjectTypeIndexer","isStatic","static","flowParseObjectTypeInternalSlot","flowParseObjectTypeMethodish","flowParseFunctionTypeParam","flowParseObjectTypeCallProperty","valueNode","callProperties","indexers","internalSlots","endDelim","exact","inexact","protoStartLoc","inexactStartLoc","propOrInexact","flowParseObjectTypeProperty","flowObjectTypeSemicolon","isInexactToken","proto","flowCheckGetterSetterParams","paramCount","_startLoc","node2","qualification","flowParseGenericType","flowParseTypeofType","flowParsePrimaryType","flowParseTupleType","first","lh","isThis","reinterpretTypeAsFunctionTypeParam","flowIdentToTypeAnnotation","isGroupedType","parseLiteralAtNode","createIdentifier","flowParsePostfixType","seenOptionalIndexedAccess","objectType","indexType","flowParsePrefixType","flowParseAnonFunctionWithoutParens","param","flowParseIntersectionType","flowParseUnionType","allowPrimitiveOverride","typeCastToParameter","allowExpressionBody","forwardNoArrowParamsConversionAt","parseFunctionBodyAndFinish","parseStatementLike","flowParseEnumDeclaration","parseExpressionStatement","expr","shouldParseExportDeclaration","isExportDefaultSpecifier","parseExportDefaultExpression","parseConditional","setOptionalParametersError","originalNoArrowAt","consequent","failed","tryParseConditionalConsequent","valid","getArrowLikeExpressions","alternate","parseMaybeAssign","parseMaybeAssignAllowIn","disallowInvalid","arrows","finishArrowValidation","every","_node$extra","toAssignableList","trailingCommaLoc","checkParams","result","parseParenItem","typeCastNode","assertModuleNodeAllowed","parseExportDeclaration","declarationNode","parseExportSpecifiers","parseExportFrom","eatExportStar","maybeParseExportNamespaceSpecifier","hasNamespace","parseClassId","isStatement","optionalId","parseClassMember","member","parseClassMemberFromModifier","isIterator","readIterator","fullWord","left","exprList","toReferencedList","isParenthesizedExpr","_expr$extra","parseArrayLike","close","canBePattern","isTuple","isParenthesized","isClassMethod","isClassProperty","isNonstaticConstructor","isThisParam","pushClassPrivateMethod","parseClassSuper","superTypeParameters","implemented","checkGetterSetterParams","parsePropertyNamePrefixOperator","parseObjPropValue","parseAssignableListItemTypes","parseMaybeDefault","checkImportReflection","module","parseImportSpecifierLocal","specifier","local","finishImportSpecifier","isPotentialImportPhase","isExport","applyImportPhase","phase","parseImportSpecifier","importedIsString","isInTypeOnlyImport","isMaybeTypeOnly","firstIdent","imported","specifierTypeKind","as_ident","specifierIsTypeImport","checkReservedWord","parseBindingAtom","parseFunctionParams","parseVarId","decl","parseAsyncArrowFromCallExpression","call","shouldParseAsyncArrow","afterLeftParse","_jsx","jsx","currentContext","_jsx2","_jsx3","abort","_arrowExpression$extr","arrowExpression","maybeUnwrapTypeCastExpression","async","parseArrow","shouldParseArrow","setArrowFunctionParameters","allowDuplicates","isArrowFunction","strictModeChanged","parseParenAndDistinguishExpression","canBeArrow","parseSubscripts","parseCallExpressionArguments","parseAsyncArrowWithTypeParameters","subscriptState","isLookaheadToken_lt","typeArguments","parseNewCallee","targs","parseArrowExpression","parseTopLevel","program","fileNode","skipFlowComment","hasFlowCommentCompletion","commentSkip","shiftToFirstNonWhiteSpace","ch2","ch3","flowEnumErrorBooleanMemberNotInitialized","flowEnumErrorInvalidMemberInitializer","enumContext","flowEnumErrorNumberMemberNotInitialized","flowEnumErrorStringMemberInconsistentlyInitailized","flowEnumMemberInit","endOfInit","literal","flowEnumMemberRaw","flowEnumCheckExplicitTypeMismatch","expectedType","flowEnumMembers","seenNames","members","booleanMembers","numberMembers","stringMembers","defaultedMembers","hasUnknownMembers","memberNode","toUpperCase","flowEnumStringMembers","initializedMembers","flowEnumParseExplicitType","flowEnumBody","nameLoc","empty","boolsLen","numsLen","strsLen","defaultedLen","afterNext","entities","__proto__","quot","amp","apos","nbsp","iexcl","cent","pound","curren","yen","brvbar","sect","uml","copy","ordf","laquo","not","shy","reg","macr","deg","plusmn","sup2","sup3","acute","micro","para","middot","cedil","sup1","ordm","raquo","frac14","frac12","frac34","iquest","Agrave","Aacute","Acirc","Atilde","Auml","Aring","AElig","Ccedil","Egrave","Eacute","Ecirc","Euml","Igrave","Iacute","Icirc","Iuml","ETH","Ntilde","Ograve","Oacute","Ocirc","Otilde","Ouml","times","Oslash","Ugrave","Uacute","Ucirc","Uuml","Yacute","THORN","szlig","agrave","aacute","acirc","atilde","auml","aring","aelig","ccedil","egrave","eacute","ecirc","euml","igrave","iacute","icirc","iuml","eth","ntilde","ograve","oacute","ocirc","otilde","ouml","divide","oslash","ugrave","uacute","ucirc","uuml","yacute","thorn","yuml","OElig","oelig","Scaron","scaron","Yuml","fnof","circ","Alpha","Beta","Gamma","Delta","Epsilon","Zeta","Eta","Theta","Iota","Kappa","Lambda","Mu","Nu","Xi","Omicron","Pi","Rho","Sigma","Tau","Upsilon","Phi","Chi","Psi","Omega","alpha","beta","gamma","delta","epsilon","zeta","eta","theta","iota","kappa","lambda","mu","nu","xi","omicron","pi","rho","sigmaf","sigma","tau","upsilon","phi","chi","psi","omega","thetasym","upsih","piv","ensp","emsp","thinsp","zwnj","zwj","lrm","rlm","ndash","mdash","lsquo","rsquo","sbquo","ldquo","rdquo","bdquo","dagger","Dagger","bull","hellip","permil","prime","Prime","lsaquo","rsaquo","oline","frasl","euro","image","weierp","real","trade","alefsym","larr","uarr","rarr","darr","harr","crarr","lArr","uArr","rArr","dArr","hArr","forall","part","exist","nabla","isin","notin","ni","prod","sum","minus","lowast","radic","infin","ang","and","or","cap","cup","int","there4","sim","cong","asymp","ne","equiv","le","ge","sub","sup","nsub","sube","supe","oplus","otimes","perp","sdot","lceil","rceil","lfloor","rfloor","lang","rang","loz","spades","clubs","hearts","diams","JsxErrors","AttributeIsEmpty","MissingClosingTagElement","openingTagName","MissingClosingTagFragment","UnexpectedSequenceExpression","HTMLEntity","UnsupportedJsxValue","UnterminatedJsxContent","UnwrappedAdjacentJSXElements","isFragment","getQualifiedJSXName","namespace","JSXParserMixin","jsxReadToken","jsxReadEntity","jsxReadNewLine","normalizeCRLF","jsxReadString","codePoint","count","desc","entity","XHTMLEntities","jsxReadWord","jsxParseIdentifier","jsxParseNamespacedName","jsxParseElementName","jsxParseAttributeValue","setContext","jsxParseExpressionContainer","jsxParseEmptyExpression","jsxParseSpreadChild","previousContext","jsxParseAttribute","jsxParseOpeningElementAt","jsxParseOpeningElementAfterName","selfClosing","jsxParseClosingElementAt","jsxParseElementAt","children","openingElement","closingElement","contents","openingFragment","closingFragment","jsxParseElement","newContext","TypeScriptScope","enums","constEnums","classes","exportOnlyBindings","TypeScriptScopeHandler","importsStack","hasImport","allowShadow","isConst","wasConst","getOwn","hasOwnProperty","unwrapParenthesizedExpression","LValParser","_node$extra3","_node$extra2","operator","arg","checkToRestConversion","elt","element","toReferencedListDeep","parseSpread","parseRestBinding","parseBindingList","ParseBindingListFlags","parseObjectLike","closeCharCode","allowEmpty","elts","checkCommaAfterRest","parseDecorator","parseAssignableListItem","parseBindingRestProperty","parseBindingProperty","parsePropertyName","_left","ObjectProperty","checkLVal","in","checkClashes","hasParenthesizedAncestor","_expression$extra","checkIdentifier","validity","ParseErrorClass","isParenthesizedExpression","nextAncestor","child","declareNameFromIdentifier","identifier","allowPattern","nonNull","x","assert","TSErrors","AbstractMethodHasImplementation","methodName","AbstractPropertyHasInitializer","propertyName","AccesorCannotDeclareThisParameter","AccesorCannotHaveTypeParameters","AccessorCannotBeOptional","ClassMethodHasDeclare","ClassMethodHasReadonly","ConstInitiailizerMustBeStringOrNumericLiteralOrLiteralEnumReference","ConstructorHasTypeParameters","DeclareAccessor","DeclareClassFieldHasInitializer","DeclareFunctionHasImplementation","DuplicateAccessibilityModifier","modifier","DuplicateModifier","EmptyHeritageClauseType","EmptyTypeArguments","EmptyTypeParameters","ExpectedAmbientAfterExportDeclare","ImportAliasHasImportType","IncompatibleModifiers","modifiers","IndexSignatureHasAbstract","IndexSignatureHasAccessibility","IndexSignatureHasDeclare","IndexSignatureHasOverride","IndexSignatureHasStatic","InitializerNotAllowedInAmbientContext","InvalidModifierOnTypeMember","InvalidModifierOnTypeParameter","InvalidModifierOnTypeParameterPositions","InvalidModifiersOrder","orderedModifiers","InvalidPropertyAccessAfterInstantiationExpression","InvalidTupleMemberLabel","MissingInterfaceName","MixedLabeledAndUnlabeledElements","NonAbstractClassHasAbstractMethod","NonClassMethodPropertyHasAbstractModifer","OptionalTypeBeforeRequired","OverrideNotInSubClass","PrivateElementHasAbstract","PrivateElementHasAccessibility","ReadonlyForMethodSignature","ReservedArrowTypeParam","ReservedTypeAssertion","SetAccesorCannotHaveOptionalParameter","SetAccesorCannotHaveRestParameter","SetAccesorCannotHaveReturnType","SingleTypeParameterWithoutTrailingComma","typeParameterName","StaticBlockCannotHaveModifier","TupleOptionalAfterType","TypeAnnotationAfterAssign","TypeImportCannotSpecifyDefaultAndNamed","TypeModifierIsUsedInTypeExports","TypeModifierIsUsedInTypeImports","UnexpectedParameterModifier","UnexpectedReadonly","UnexpectedTypeAnnotation","UnexpectedTypeCastInParameter","UnsupportedImportTypeArgument","UnsupportedParameterPropertyKind","UnsupportedSignatureParameterKind","keywordTypeFromName","tsIsAccessModifier","tsIsVarianceAnnotations","typescript","TypeScriptParserMixin","tsParseInOutModifiers","tsParseModifiers","bind","allowedModifiers","disallowedModifiers","errorTemplate","tsParseConstModifier","tsParseInOutConstModifiers","tsIsIdentifier","tsTokenCanFollowModifier","tsNextTokenCanFollowModifier","tsParseModifier","stopOnStartOfClassStaticBlock","tsIsStartOfStaticBlocks","tsTryParse","modified","enforceOrder","before","after","incompatible","mod1","mod2","accessibility","tsIsListTerminator","tsParseList","parseElement","tsParseDelimitedList","refTrailingCommaPos","tsParseDelimitedListWorker","expectSuccess","trailingCommaPos","tsParseBracketedList","bracket","skipFirstToken","tsParseImportType","qualifier","tsParseEntityName","tsParseTypeArguments","allowReservedWords","tsParseTypeReference","typeName","tsParseThisTypePredicate","lhs","parameterName","tsParseTypeAnnotation","asserts","tsParseThisTypeNode","tsParseTypeQuery","exprName","tsParseTypeParameter","parseModifiers","tsParseTypeParameterName","constraint","tsEatThenParseType","tsTryParseTypeParameters","tsParseTypeParameters","tsFillSignature","returnToken","signature","returnTokenRequired","paramsKey","returnTypeKey","tsParseBindingListForSignature","tsParseTypeOrTypePredicateAnnotation","tsParseTypeMemberSemicolon","tsParseSignatureMember","tsIsUnambiguouslyIndexSignature","tsTryParseIndexSignature","tsLookAhead","parameters","tsTryParseTypeAnnotation","tsParsePropertyOrMethodSignature","readonly","nodeAny","firstParameter","tsParseTypeMember","idx","tsParseTypeLiteral","tsParseObjectTypeMembers","tsIsStartOfMappedType","tsParseMappedTypeParameter","tsExpectThenParseType","tsParseMappedType","nameType","tsParseType","tsTryParseType","tsParseTupleType","elementTypes","tsParseTupleElementType","seenOptionalElement","labeledElements","elementNode","_labeledElements","checkType","isLabeled","labeled","isWord","chAfterWord","wordName","typeOrLabel","tsParseNonArrayType","labeledNode","optionalTypeNode","restNode","tsParseParenthesizedType","tsParseFunctionOrConstructorType","abstract","tsInAllowConditionalTypesContext","tsParseLiteralTypeNode","tsParseTemplateLiteralType","parseTemplate","parseTemplateSubstitution","tsParseThisTypeOrThisTypePredicate","thisKeyword","parseMaybeUnary","nodeType","tsParseArrayTypeOrHigher","tsParseTypeOperator","tsParseTypeOperatorOrHigher","tsCheckTypeAnnotationForReadOnly","tsParseInferType","tsParseConstraintForInferType","tsInDisallowConditionalTypesContext","isTypeOperator","tsParseUnionOrIntersectionType","parseConstituentType","hasLeadingOperator","tsParseIntersectionTypeOrHigher","tsParseUnionTypeOrHigher","tsIsStartOfFunctionType","tsIsUnambiguouslyStartOfFunctionType","tsSkipParameterStart","previousErrorCount","_unused2","tsInType","t","tsParseTypePredicateAsserts","thisTypePredicate","typePredicateVariable","tsParseTypePredicatePrefix","tsTryParseTypeOrTypePredicateAnnotation","eatColon","tsParseNonConditionalType","extendsType","trueType","falseType","isAbstractConstructorSignature","tsParseTypeAssertion","tsParseHeritageClause","originalStartLoc","delimitedList","tsParseInterfaceDeclaration","tsParseTypeAliasDeclaration","tsInNoContext","cb","oldContext","oldInDisallowConditionalTypesContext","tsNextThenParseType","tsParseEnumMember","initializer","tsParseEnumDeclaration","tsParseModuleBlock","parseBlockOrModuleBlockBody","tsParseModuleOrNamespaceDeclaration","nested","inner","tsParseAmbientExternalModuleDeclaration","global","tsParseImportEqualsDeclaration","maybeDefaultIdentifier","moduleReference","tsParseModuleReference","tsIsExternalModuleReference","tsParseExternalModuleReference","f","tsTryParseAndCatch","tsTryParseDeclare","nany","startType","tsInAmbientContext","parseFunctionStatement","parseClass","parseVarStatement","tsParseDeclaration","tsTryParseExportDeclaration","tsParseExpressionStatement","mod","tsCheckLineTerminator","tsParseAbstractDeclaration","tsTryParseGenericAsyncArrowFunction","oldMaybeInArrowParameters","tsParseTypeArgumentsInExpression","reScan_lt","reScan_lt_gt","tsIsDeclarationStart","override","pp","parameter","isSimpleParameter","tsDisallowOptionalPattern","bodilessType","registerFunctionStatementId","tsCheckForInvalidTypeCasts","items","isInParens","nonNullExpression","isOptionalCall","missingParenErrorLoc","atPossibleAsyncArrow","asyncArrowFn","parseTaggedTemplateExpression","tokenType","_callee$extra","parseExprOp","leftStartLoc","minPrec","isSatisfies","checkKeywords","checkDuplicateExports","importNode","parseMaybeImportPhase","parseImportSpecifiersAndAfter","isAbstractClass","cls","allowMissingInitializer","declarations","isValidAmbientConstInitializer","parseStatementContent","parseAccessModifier","tsHasSomeModifiers","callParseClassMemberWithIsStatic","parseClassStaticBlock","parseClassMemberWithIsStatic","hadSuperClass","parsePostMemberNameModifiers","methodOrProp","isDeclare","isIdentifier","parseClassPropertyAnnotation","definite","parseClassAccessorProperty","declareClassPrivateMethodInScope","_typeCast","_typeCast2","typeCast","_typeParameters","reportReservedArrowTypeParam","trailingComma","sawUnary","toAssignableParenthesizedExpression","TSTypeCastExpression","TSParameterProperty","TSNonNullExpression","TSAsExpression","TSSatisfiesExpression","TSTypeAssertion","parseMaybeDecoratorArguments","canHaveLeadingDecorator","getGetterSetterExpectedParamCount","baseCount","firstParam","hasContextParam","parseCatchClauseParam","oldIsAmbientContext","oldInAbstractClass","maybeTakeDecorators","hasBody","shouldParseAsAmbientContext","getExpression","parseExportSpecifier","isString","isInTypeExport","parseTypeOnlyImportExportSpecifier","isImport","isInTypeOnlyImportExport","leftOfAsKey","rightOfAsKey","leftOfAs","rightOfAs","hasTypeSpecifier","canParseAsKeyword","firstAs","secondAs","parseModuleExportName","kindKey","isPossiblyLiteralEnum","expressions","isUncomputedMemberExpressionChain","isNumber","isNegativeNumber","PlaceholderErrors","ClassNameIsRequired","UnexpectedSpace","placeholders","PlaceholdersParserMixin","parsePlaceholder","assertNoSpace","finishPlaceholder","isFinished","chStartsBindingIdentifier","verifyBreakContinue","isBreak","parseStatementOrSloppyAnnexBFunctionDeclaration","parseBlock","createNewLexicalScope","parseFunctionId","requireId","oldStrict","parseClassBody","startsWith","maybeParseExportDefaultSpecifier","_specifiers","checkExport","hasStarImport","maybeParseStarImportSpecifier","parseNamedImportSpecifiers","parseImportSource","v8intrinsic","V8IntrinsicMixin","parseV8Intrinsic","v8IntrinsicStartLoc","parseIdentifierName","expectedConfig","expectedName","expectedOptions","expectedKeys","expectedOptionsIsEmpty","p","option","find","PIPELINE_PROPOSALS","TOPIC_TOKENS","RECORD_AND_TUPLE_SYNTAX_TYPES","validatePlugins","decoratorsBeforeExport","allowCallParenthesized","proposalList","tupleSyntaxIsHash","syntaxType","tokenList","moduleAttributesVersionPluginOption","missingPlugins","mixinPlugins","mixinPluginNames","defaultOptions","sourceFilename","allowAwaitOutsideFunction","allowReturnOutsideFunction","allowNewTargetOutsideFunction","allowImportExportEverywhere","allowSuperOutsideMethod","allowUndeclaredExports","createParenthesizedExpressions","getOptions","opts","ExpressionParser","checkProto","isRecord","protoRef","used","shouldExitDescending","disallowIn","disallowInAnd","parseExpressionBase","allowInAnd","parseMaybeAssignDisallowIn","resultError","_resultError$loc","parseYield","ownExpressionErrors","parseMaybeConditional","startIndex","parseExprOps","parseMaybeUnaryOrPrivate","op","prec","checkPipelineAtInfixOperator","logical","coalesce","parseExprOpRightExpr","finishedNode","nextOp","withTopicBindingContext","parseHackPipeBody","parseSmartPipelineBodyInStyle","parseExprOpBaseRightExpr","withSoloAwaitPermittingContext","parseFSharpPipelineBody","_body$extra","requiredParentheses","topicReferenceWasUsedInCurrentContext","checkExponentialAfterUnary","isAwait","isAwaitAllowed","parseAwait","update","isDelete","parseUpdate","isAmbiguousAwait","updateExpressionNode","parseExprSubscripts","maybeAsyncArrow","parseBind","parseCoverCallAndAsyncArrowHead","parseMember","parseNoCallExpr","tag","quasi","expectImportAttributesPlugin","dynamicImport","allowPlaceholder","nodeForExtra","oldInFSharpPipelineDirectBody","addTrailingCommaExtraToNode","parseExprListItem","_call$extra","parseSuper","parseImportMetaProperty","parseDo","parseFunctionOrFunctionSent","parseDecorators","parseNewOrNewTarget","parseTopicReferenceThenEqualsSign","parseTopicReference","pipeProposal","parseModuleExpression","parseAsyncFunctionExpression","parseAsyncArrowUnaryFunction","topicTokenType","topicTokenValue","finishTopicReference","testTopicReferenceConfiguration","topicReferenceIsAllowedInCurrentContext","registerTopicReference","meta","parseMetaProperty","parseFunction","innerStartLoc","spreadStartLoc","optionalCommaStartLoc","spreadNodeStartLoc","innerEndLoc","arrowNode","wrapParenthesis","parenExpression","metaProp","parseNew","parseExprList","parseTemplateElement","isTagged","elemStart","elem","isTail","endOffset","elemEnd","cooked","tail","curElt","quasis","propHash","parsePropertyDefinition","maybeAsyncOrAccessorProp","keyName","_params","finishedProp","generator","isExpression","hasStrictModeDirective","nonSimple","isSimpleParamList","formalParameters","reservedTest","delegating","delegate","childExpr","isSimpleReference","checkSmartPipeTopicBodyEarlyErrors","callback","outerContextTopicState","withSmartMixTopicForbiddingContext","outerContextSoloAwaitState","prodParamToSet","prodParamToClear","ret","revertScopes","parseProgram","loopLabel","switchLabel","loneSurrogate","keywordRelationalOperator","babel7CompatTokens","hashEndPos","hashEndLoc","backquoteEnd","backquoteEndLoc","startToken","templateValue","templateElementEnd","templateElementEndLoc","endToken","StatementParser","interpreter","parseInterpreterDirective","finishedProgram","stmtToDirective","directiveLiteral","hasFollowingBindingAtom","endCh","chStartsBindingPattern","hasInLineFollowingBindingIdentifier","startsUsingForOf","startsAwaitUsing","parseModuleItem","ParseStatementFlag","parseStatementListItem","allowLabeledFunction","parseStatement","starttype","allowDeclaration","allowFunctionDeclaration","parseBreakContinueStatement","parseDebuggerStatement","parseDoWhileStatement","parseForStatement","parseIfStatement","parseReturnStatement","parseSwitchStatement","parseThrowStatement","parseTryStatement","parseWhileStatement","parseWithStatement","parseEmptyStatement","nextTokenCharCode","isAsyncFunction","maybeName","parseLabeledStatement","decoratorsEnabledBeforeExport","maybeDecorators","classNode","exportNode","allowExport","paramsStartLoc","lab","parseHeaderExpression","awaitAt","parseFor","startsWithLet","startsWithAwaitUsing","starsWithUsingDeclaration","isLetOrUsing","initNode","parseVar","isForIn","parseForIn","startsWithAsync","isForOf","isHangingDeclaration","ParseFunctionFlag","discriminant","cases","cur","sawDefault","isCase","block","handler","clause","finalizer","statementStart","parsedNonDirective","await","isFor","hangingDeclaration","isDeclaration","hadConstructor","publicMethod","privateMethod","publicProp","privateProp","accessorProp","publicMember","parseClassElementName","isPrivate","maybeQuestionTokenStartLoc","pushClassPrivateProperty","pushClassProperty","pushClassAccessorProperty","_member$decorators","parseInitializer","hasDefault","parseAfterDefault","hasStar","parseAfterNamespace","isFromRequired","hasSpecifiers","maybeParseExportNamedSpecifiers","hasDeclaration","maybeParseExportDeclaration","_node2$declaration","isTypeExport","assertions","nextType","hasFrom","nextAfterFrom","maybeParseImportAttributes","checkJSONModuleImport","checkNames","isDefault","isFrom","_declaration$extra","nodes","surrogate","isJSONModuleImport","_node$assertions","nonDefaultNamedSpecifier","phaseIdentifier","isImportPhase","isPrecedingIdImportPhase","parseImportSourceAndAttributes","maybeParseDefaultImportSpecifier","parseNext","_node$specifiers","parseImportAttributes","attrs","attrNames","parseModuleAttributes","useWith","importSpecifier","Parser","pluginsMap","pluginMap","_options","getParser","ast","moduleError","generateExportedTokenTypes","internalTokenTypes","tokTypes","getParserClass","parserClassCache","pluginsFromOptions","pluginList"],"mappings":";;;;;;;;;;;;;;;;;AAOO,MAAMA,QAAQ,CAAC;EAKpBC,WAAWA,CAACC,IAAY,EAAEC,GAAW,EAAEC,KAAa,EAAE;IAAA,IAAA,CAJtDF,IAAI,GAAA,KAAA,CAAA;IAAA,IAAA,CACJG,MAAM,GAAA,KAAA,CAAA;IAAA,IAAA,CACND,KAAK,GAAA,KAAA,CAAA;IAGH,IAAI,CAACF,IAAI,GAAGA,IAAI;IAChB,IAAI,CAACG,MAAM,GAAGF,GAAG;IACjB,IAAI,CAACC,KAAK,GAAGA,KAAK;EACpB;AACF;AAEO,MAAME,cAAc,CAAC;EAM1BL,WAAWA,CAACM,KAAe,EAAEC,GAAc,EAAE;IAAA,IAAA,CAL7CD,KAAK,GAAA,KAAA,CAAA;IAAA,IAAA,CACLC,GAAG,GAAA,KAAA,CAAA;IAAA,IAAA,CACHC,QAAQ,GAAA,KAAA,CAAA;IAAA,IAAA,CACRC,cAAc,GAAA,KAAA,CAAA;IAGZ,IAAI,CAACH,KAAK,GAAGA,KAAK;IAElB,IAAI,CAACC,GAAG,GAAGA,GAAG;EAChB;AACF;AAQO,SAASG,8BAA8BA,CAC5CC,QAAkB,EAClBC,YAAoB,EACpB;EACA,MAAM;IAAEX,IAAI;IAAEG,MAAM;IAAED;EAAO,CAAA,GAAGQ,QAAQ;EACxC,OAAO,IAAIZ,QAAQ,CAACE,IAAI,EAAEG,MAAM,GAAGQ,YAAY,EAAET,KAAK,GAAGS,YAAY,CAAC;AACxE;AC5CA,IAAkBC,cAAc,GAAA;EAAAC,WAAA,EAAA,2BAAA;EAAAC,qBAAA,EAAA;AAAA,CAAA;AAqBhC,MAAMC,OAAO,GAAGA,CAACC,IAAc,EAAEC,IAAI,GAAGD,IAAI,CAACE,MAAM,GAAG,CAAC,MAAM;EAC3DC,GAAGA,CAAAA,EAAyB;IAC1B,OAAOH,IAAI,CAACI,MAAM,CAChB,CAACC,MAAM,EAAEC,GAAG,KAEVD,MAAM,CAACC,GAAG,CAAC,EACb,IACF,CAAC;EACF,CAAA;EACDC,GAAGA,CAAgBC,KAAc,EAAE;IACjCR,IAAI,CAACI,MAAM,CAET,CAACK,IAAI,EAAEH,GAAG,EAAEI,CAAC,KAAMA,CAAC,KAAKT,IAAI,GAAIQ,IAAI,CAACH,GAAG,CAAC,GAAGE,KAAK,GAAIC,IAAI,CAACH,GAAG,CAAE,EAChE,IACF,CAAC;EACH;AACF,CAAC,CAAC;AAEF,MAAMK,WAAW,GAAGA,CAClB5B,WAAwB,EACxB6B,UAAe,EACfC,WAAgB,KAEhBC,MAAM,CAACd,IAAI,CAACa,WAAW,CAAC,CACrBE,GAAG,CAACT,GAAG,IAAI,CAACA,GAAG,EAAEO,WAAW,CAACP,GAAG,CAAC,CAAC,CAAC,CACnCU,MAAM,CAAC,CAAC,GAAGC,UAAU,CAAC,KAAK,CAAC,CAACA,UAAU,CAAC,CACxCF,GAAG,CAAC,CAAC,CAACT,GAAG,EAAEW,UAAU,CAAC,KAAK,CAC1BX,GAAG,EACH,OAAOW,UAAU,KAAK,UAAU,GAC5B;EAAET,KAAK,EAAES,UAAU;EAAEC,UAAU,EAAE;AAAM,CAAC,GACxC,OAAOD,UAAU,CAAClB,OAAO,KAAK,QAAQ,GAAAe,MAAA,CAAAK,MAAA,KACjCF,UAAU,EAAKlB,OAAO,CAACkB,UAAU,CAAClB,OAAO,CAACqB,KAAK,CAAC,GAAG,CAAC,CAAC,IAC1DH,UAAU,CACf,CAAC,CACDb,MAAM,CACL,CAACiB,QAAQ,EAAE,CAACf,GAAG,EAAEW,UAAU,CAAC,KAC1BH,MAAM,CAACQ,cAAc,CAACD,QAAQ,EAAEf,GAAG,EAAAQ,MAAA,CAAAK,MAAA,CAAA;EACjCI,YAAY,EAAE;AAAI,CAAA,EACfN,UAAU,CACd,CAAC,EACJH,MAAM,CAACK,MAAM,CAAC,IAAIpC,WAAW,CAAA,CAAE,EAAE6B,UAAU,CAC7C,CAAC;AC5DL,IAAeY,YAAA,GAAA;EACbC,uBAAuB,EAAE;IACvBC,OAAO,EAA2D,yDAAA;IAClEC,IAAI,EAAE/B,cAAc,CAACE;EACtB,CAAA;EACD8B,mBAAmB,EAAE;IACnBF,OAAO,EAAqE,mEAAA;IAC5EC,IAAI,EAAE/B,cAAc,CAACE;EACvB;AACF,CAAC;ACXD,MAAM+B,gBAAgB,GAAG;EACvBC,YAAY,EAAE,6BAA6B;EAC3CC,oBAAoB,EAAE,uBAAuB;EAC7CC,iBAAiB,EAAE,uBAAuB;EAC1CC,uBAAuB,EAAE,2BAA2B;EACpDC,qBAAqB,EAAE,wBAAwB;EAC/CC,WAAW,EAAE,cAAc;EAC3BC,cAAc,EAAE,kBAAkB;EAClCC,cAAc,EAAE,kBAAkB;EAClCC,YAAY,EAAE,UAAU;EACxBC,gBAAgB,EAAE,yBAAyB;EAC3CC,UAAU,EAAE,YAAY;EACxBC,eAAe,EAAE,kBAAkB;EACnCC,sBAAsB,EAAE,0BAA0B;EAClDC,wBAAwB,EAAE,4BAA4B;EACtDC,aAAa,EAAE,8BAA8B;EAC7CC,uBAAuB,EAAE,0BAA0B;EACnDC,WAAW,EAAE,cAAc;EAC3BC,gBAAgB,EAAE;IAChBC,IAAI,EAAE,kBAAkB;IACxBC,KAAK,EAAE;EACR,CAAA;EACDC,kBAAkB,EAAE,sBAAsB;EAC1CC,eAAe,EAAE;AACnB,CAAC;AAkBD,MAAMC,iBAAiB,GAAGA,CAAC;EAAEC,IAAI;EAAEC;AAA4B,CAAC,KAC9DD,IAAI,KAAK,kBAAkB,GACvBxB,gBAAgB,CAACkB,gBAAgB,CAACQ,MAAM,CAACD,MAAM,CAAC,CAAqB,GACrEzB,gBAAgB,CAACwB,IAAI,CAAC;ACvB5B,IAAeG,cAAA,GAAA;EACbC,mBAAmB,EAAEA,CAAC;IAAEC;GAA+B,KAChDA,KAAAA,IAAgC,4BAAA;EACvCC,gBAAgB,EACd,6DAA6D;EAC/DC,qCAAqC,EACnC,0EAA0E;EAC5EC,sBAAsB,EACpB,6DAA6D;EAC/DC,mCAAmC,EACjC,0DAA0D;EAC5DC,8BAA8B,EAC5B,sDAAsD;EACxDC,2BAA2B,EACzB,wFAAwF;EAC1FC,sBAAsB,EACpB,kFAAkF;EACpFC,uBAAuB,EAAE,iDAAiD;EAC1EC,cAAc,EAAE,uDAAuD;EACvEC,cAAc,EAAE,0DAA0D;EAC1EC,sBAAsB,EACpB,kEAAkE;EACpEC,qBAAqB,EAAE,mDAAmD;EAC1EC,4BAA4B,EAC1B,4DAA4D;EAC9DC,qBAAqB,EAAE,2CAA2C;EAClEC,kBAAkB,EAAE,yCAAyC;EAC7DC,sBAAsB,EAAE,mCAAmC;EAC3DC,6BAA6B,EAAEA,CAAC;IAC9BjB;GAGD,KAA+BA,0BAAAA,IAAmB,eAAA;EACnDkB,oCAAoC,EAClC,iHAAiH;EACnHC,qBAAqB,EACnB,2JAA2J;EAC7JC,2BAA2B,EACzB,qHAAqH;EACvHC,oBAAoB,EAClB,iFAAiF;EACnFC,oBAAoB,EAClB,2JAA2J;EAC7JC,kBAAkB,EAAE,iDAAiD;EACrEC,oBAAoB,EAAE,+CAA+C;EACrEC,kBAAkB,EAAE,0CAA0C;EAC9DC,sBAAsB,EACpB,oGAAoG;EACtGC,oBAAoB,EAAE,0CAA0C;EAChEC,sBAAsB,EAAE,6CAA6C;EACrEC,eAAe,EAAEA,CAAC;IAAEC;GAAoC,KACjDA,KAAAA,UAA8E,oEAAA;EACrFC,cAAc,EAAE,qCAAqC;EACrDC,oBAAoB,EAAE,oCAAoC;EAC1DC,gBAAgB,EAAE,oCAAoC;EACtDC,0BAA0B,EAAE,yBAAyB;EACrDC,qBAAqB,EAAEA,CAAC;IACtBC,SAAS;IACTN;EAID,CAAA,KACE,wGAAuGM,SAAU,SAAQN,UAAqC,2BAAA;EACjKO,6BAA6B,EAC3B,gEAAgE;EAElEC,sBAAsB,EAAEA,CAAC;IACvB3C;GAGD,SAEGA,IAAI,KAAK,gBAAgB,GAAG,QAAQ,GAAG,QACiB,0DAAA;EAC5D4C,UAAU,EAAE,qDAAqD;EAEjEC,UAAU,EAAE,yDAAyD;EACrEC,QAAQ,EAAE,+DAA+D;EACzEC,iCAAiC,EAC/B,qEAAqE;EAEvEC,oBAAoB,EAAEA,CAAC;IACrBhD;GAGD,oBAAoBA,IAAI,KAAK,gBAAgB,GAAG,OAAO,GAAG,UAAa,GAAA;EAExEiD,4BAA4B,EAC1B,4EAA4E;EAC9EC,aAAa,EAAE,+BAA+B;EAC9CC,yBAAyB,EACvB,0NAA0N;EAC5NC,qBAAqB,EAAEA,CAAC;IAAEC;GAAoC,KAC2BA,uFAAAA,UAAyB,eAAA;EAClHC,+BAA+B,EAC7B,4DAA4D;EAC9DC,eAAe,EAAEA,CAAC;IAAEC;GAA+C,sCAE/DA,gBAAgB,KAAK,CAAC,GAAG,cAAc,GAAG,sBACzC,GAAA;EACLC,0BAA0B,EAAE,kCAAkC;EAC9DC,wBAAwB,EAAE,qCAAqC;EAC/DC,2BAA2B,EACzB,oDAAoD;EACtDC,4BAA4B,EAAE,2CAA2C;EACzEC,0BAA0B,EACxB,kDAAkD;EACpDC,yBAAyB,EACvB,8EAA8E;EAChFC,oBAAoB,EAAE,wBAAwB;EAC9CC,gBAAgB,EAAE,2BAA2B;EAC7CC,2BAA2B,EAAE,yCAAyC;EACtEC,cAAc,EAAE,kBAAkB;EAClCC,YAAY,EAAEA,CAAC;IAAEC;GAA0B,KACbA,4BAAAA,KAAQ,GAAA;EACtCC,qBAAqB,EAAE,gCAAgC;EACvDC,6BAA6B,EAAE,sCAAsC;EACrEC,0BAA0B,EAAEA,CAAC;IAAEC;GAAwC,KACvCA,8BAAAA,YAAe,GAAA;EAC/CC,iBAAiB,EAAEA,CAAC;IAAEtI;GAA4C,KAC1CA,sBAAAA,cAAiB,GAAA;EACzCuI,UAAU,EAAEA,CAAC;IAAEC;EAAsC,CAAA,KACtB5E,6BAAAA,iBAAiB,CAAC4E,QAAQ,CAAI,GAAA;EAC7DC,iBAAiB,EAAEA,CAAC;IAAED;EAAsC,CAAA,KACrB5E,qCAAAA,iBAAiB,CAAC4E,QAAQ,CAAI,GAAA;EACrEE,aAAa,EAAE,iBAAiB;EAChCC,wBAAwB,EACtB,gEAAgE;EAClEC,wBAAwB,EAAEA,CAAC;IAAEC;GAAoC,KACtCA,yBAAAA,UAAc,IAAA;EACzCC,8BAA8B,EAAE,2CAA2C;EAC3EC,6BAA6B,EAAEA,CAAC;IAC9B/I;GAGD,KAAsBA,iBAAAA,cAAgC,kBAAA;EACvDgJ,6BAA6B,EAAE,4BAA4B;EAC3DC,qBAAqB,EACnB,wEAAwE;EAC1EC,4BAA4B,EAAE,mCAAmC;EACjEC,kBAAkB,EAAEA,CAAC;IAAEC;GAAkC,KAC7CA,UAAAA,SAAiC,wBAAA;EAC7CC,mBAAmB,EACjB,6EAA6E;EAC/EC,yBAAyB,EAAE,uCAAuC;EAClEC,oBAAoB,EAAE,kCAAkC;EACxDC,gBAAgB,EAAE,2BAA2B;EAC7CC,qBAAqB,EACnB,6DAA6D;EAC/DC,gBAAgB,EAAE,oBAAoB;EACtCC,aAAa,EAAEA,CAAC;IAAEC;EAA4C,CAAA,sEACKA,aAAa,CAC3ErI,GAAG,CAACsI,IAAI,IAAIC,IAAI,CAACC,SAAS,CAACF,IAAI,CAAC,CAAC,CACjCG,IAAI,CAAC,IAAI,CAAI,GAAA;EAGlBC,mBAAmB,EAAEA,CAAC;IAAEL;EAA4C,CAAA,0FACmBA,aAAa,CAC/FrI,GAAG,CAACsI,IAAI,IAAIC,IAAI,CAACC,SAAS,CAACF,IAAI,CAAC,CAAC,CACjCG,IAAI,CAAC,IAAI,CAAI,GAAA;EAClBE,oBAAoB,EAAE,4CAA4C;EAClEC,yBAAyB,EACvB,qFAAqF;EACvFC,gCAAgC,EAC9B,+CAA+C;EACjDC,2BAA2B,EACzB,8DAA8D;EAChEC,iCAAiC,EAAEA,CAAC;IAAExJ;GAAsB,KACxCA,kBAAAA,GAA2C,wCAAA;EAC/DyJ,gCAAgC,EAAEA,CAAC;IACjCC;GAGD,kEAC8DA,iBAAiB,CAACC,QAAQ,CACrF,EACF,CAAK,IAAA;EACPC,qBAAqB,EAAEA,CAAC;IAAEpE;GAAkC,KAC/CA,WAAAA,SAA4B,mBAAA;EACzCqE,wBAAwB,EAAE,2BAA2B;EACrDC,iBAAiB,EAAE,8BAA8B;EACjDC,gBAAgB,EAAE,kCAAkC;EACpDC,gBAAgB,EAAE,mCAAmC;EACrDC,gCAAgC,EAC9B,6FAA6F;EAC/FC,iBAAiB,EACf,yFAAyF;EAC3FC,qBAAqB,EACnB,0DAA0D;EAC5DC,0BAA0B,EACxB,4DAA4D;EAC9DC,qBAAqB,EACnB,iEAAiE;EACnEC,SAAS,EAAE,sBAAsB;EACjCC,kBAAkB,EAAE,gDAAgD;EACpEC,gBAAgB,EAAE,uCAAuC;EACzDC,mBAAmB,EAAEA,CAAC;IAAEvL;EAA4C,CAAA,KACjE,+DAA8DA,cAAe,oCAAmCA,cAA2B,aAAA;EAC9IwL,wBAAwB,EAAEA,CAAC;IAAExL;GAA4C,KAC5CA,2BAAAA,cAAiB,GAAA;EAC9CyL,yCAAyC,EACvC,mIAAmI;EACrIC,2CAA2C,EACzC,qIAAqI;EACvIC,4CAA4C,EAC1C,sIAAsI;EACxIC,aAAa,EAAE,mDAAmD;EAClEC,iBAAiB,EAAE,+CAA+C;EAClEC,cAAc,EACZ,yFAAyF;EAC3FC,oBAAoB,EAClB,0HAA0H;EAC5HC,eAAe,EAAE,uDAAuD;EACxEC,eAAe,EACb,mJAAmJ;EACrJC,iBAAiB,EAAE,4CAA4C;EAC/DC,iBAAiB,EAAE,iDAAiD;EACpEC,wCAAwC,EACtC,kIAAkI;EACpIC,0CAA0C,EACxC,oIAAoI;EACtIC,2CAA2C,EACzC,qIAAqI;EACvIC,6BAA6B,EAAE,kCAAkC;EACjEC,gCAAgC,EAC9B,0FAA0F;EAC5FC,wBAAwB,EAAE,oCAAoC;EAC9DC,sBAAsB,EACpB,yDAAyD;EAC3DC,iBAAiB,EAAEA,CAAC;IAAEC;GAA8B,KAC3BA,uBAAAA,OAAW,IAAA;EACpCC,0BAA0B,EACxB,6DAA6D;EAC/DC,4BAA4B,EAC1B,kEAAkE;EACpEC,mBAAmB,EACjB,iEAAiE;EACnEC,0BAA0B,EACxB,yDAAyD;EAC3DC,sBAAsB,EAAE,0BAA0B;EAClDC,sBAAsB,EAAEA,CAAC;IAAE7E;GAAwC,KACpCA,6BAAAA,YAAgB,IAAA;EAC/C8E,eAAe,EAAE,wDAAwD;EACzEC,eAAe,EAAEA,CAAC;IAChBC,QAAQ;IACRxE;EAIF,CAAC,KACoBA,mBAAAA,UAAU,GAAI,KAAIA,UAAc,IAAA,GAAG,EAAG,GACvDwE,QAAQ,GAAI,eAAcA,QAAW,GAAA,GAAG,EACxC,EAAA;EACJC,kCAAkC,EAChC,kFAAkF;EACpFC,0BAA0B,EACxB,gFAAgF;EAClFC,eAAe,EAAE,iDAAiD;EAClEC,0BAA0B,EACxB,qDAAqD;EACvDC,wBAAwB,EACtB,6EAA6E;EAC/EC,iBAAiB,EACf,2DAA2D;EAC7DC,uBAAuB,EAAEA,CAAC;IACxBC,MAAM;IACNC;EAIF,CAAC,KACqCD,oCAAAA,aAAaA,MAAO,IAAGC,qBAAwB,GAAA;EACrFC,6BAA6B,EAC3B,mDAAmD;EACrDC,4BAA4B,EAC1B,kEAAkE;EACpEC,gBAAgB,EACd,uHAAuH;EACzHC,mBAAmB,EAAE,uBAAuB;EAC5CC,kBAAkB,EAAE,kCAAkC;EACtDC,kBAAkB,EAAE,+BAA+B;EACnDC,oBAAoB,EAAE,wBAAwB;EAC9CC,iCAAiC,EAC/B,uDAAuD;EACzDC,gBAAgB,EAAEA,CAAC;IAAEvO;GAA4C,KAChDA,eAAAA,cAA4C,8BAAA;EAC7DwO,sBAAsB,EACpB,uDAAuD;EACzDC,gBAAgB,EAAE,uDAAuD;EACzEC,yBAAyB,EACvB;AACJ,CAAC;AC1TD,IAAeC,gBAAA,GAAA;EACbC,YAAY,EAAE,yCAAyC;EAOvDC,mBAAmB,EAAEA,CAAC;IAAEC;GAA0C,KAC/CA,iBAAAA,aAAgC,mBAAA;EAOnDC,0BAA0B,EAAEA,CAAC;IAAEC;GAAsC,KACvDA,YAAAA,WAA8B,mBAAA;EAE5CC,cAAc,EACZ,qFAAqF;EAEvFC,mBAAmB,EAAE,wDAAwD;EAE7EC,kBAAkB,EAAE,uDAAuD;EAE3EC,UAAU,EAAE;AACd,CAAC;ACzBM,MAAMC,mCAAmC,GAAG,IAAIC,GAAG,CAAC,CACzD,yBAAyB,EACzB,sBAAsB,EACtB,uBAAuB,EACvB,iBAAiB,CACT,CAAC;AAUX,IAAeC,sBAAA,GAAA;EAEbC,iBAAiB,EACf,uJAAuJ;EACzJC,0BAA0B,EACxB,iHAAiH;EACnHC,gBAAgB,EACd,4DAA4D;EAC9DC,0BAA0B,EAAEA,CAAC;IAAEC;EAAyB,CAAC,KAChCA,uBAAAA,0BAA0BA,KAAM,mHAAkHA,KAAW,MAAA;EACtLC,eAAe,EACb,yGAAyG;EAC3GC,uBAAuB,EAAEA,CAAC;IAAEjM;GAA8C,KACnBD,qDAAAA,iBAAiB,CAAC;IACrEC;EACD,CAAA,CAAmC,kCAAA;EAMtCkM,mBAAmB,EACjB,mGAAmG;EACrGC,8BAA8B,EAC5B,iEAAiE;EACnEC,8BAA8B,EAC5B,oEAAoE;EACtEC,mBAAmB,EACjB,8DAA8D;EAChEC,sBAAsB,EACpB,sEAAsE;EACxEC,iCAAiC,EAC/B;AACJ,CAAC;;;ACDD,SAASC,uBAAuBA,CAAAC,IAAA,EAG6C;EAAA,IAHf;MAC5DC;IAEmC,CAAC,GAAAD,IAAA;IADjClP,UAAU,GAAAoP,6BAAA,CAAAF,IAAA,EAAAG,WAAA,CAAA;EAOb,OAAO,SAASlR,WAAWA,CAAC;IAAEmR,GAAG;IAAEC;EAA6B,CAAC,EAAE;IACjE,OAAOxP,WAAW,CAChBd,WAAW,EAAAiB,MAAA,CAAAK,MAAA,KACNP,UAAU,EAAA;MAAEsP;KACjB,CAAA,EAAA;MACEE,KAAKA,CACHC,SAGC,GAAG,EAAE,EACN;QACA,MAAMH,GAAG,GAAIG,SAAS,CAACH,GAAG,IAAI,EAAwB;QACtD,OAAOnR,WAAW,CAAC;UACjBmR,GAAG,EAAE,IAAIpR,QAAQ,CACf,MAAM,IAAIoR,GAAG,GAAGA,GAAG,CAAClR,IAAI,GAAG,IAAI,CAACkR,GAAG,CAAClR,IAAI,EACxC,QAAQ,IAAIkR,GAAG,GAAGA,GAAG,CAAC/Q,MAAM,GAAG,IAAI,CAAC+Q,GAAG,CAAC/Q,MAAM,EAC9C,OAAO,IAAI+Q,GAAG,GAAGA,GAAG,CAAChR,KAAK,GAAG,IAAI,CAACgR,GAAG,CAAChR,KACxC,CAAC;UACDiR,OAAO,EAAArP,MAAA,CAAAK,MAAA,CAAA,CAAA,CAAA,EAAO,IAAI,CAACgP,OAAO,EAAKE,SAAS,CAACF,OAAO;QAClD,CAAC,CAAC;MACH,CAAA;MACDA,OAAO,EAAE;QAAE3P,KAAK,EAAE2P,OAAO;QAAEjP,UAAU,EAAE;MAAO,CAAA;MAC9CQ,OAAO,EAAE;QACPvB,GAAGA,CAAAA,EAAoC;UACrC,UAAU4P,SAAS,CAAC,IAAI,CAACI,OAAO,CAAM,KAAA,IAAI,CAACD,GAAG,CAAClR,IAC7C,IAAA,IAAI,CAACkR,GAAG,CAAC/Q,MACR,GAAA;QACJ,CAAA;QACDoB,GAAGA,CAACC,KAAa,EAAE;UACjBM,MAAM,CAACQ,cAAc,CAAC,IAAI,EAAE,SAAS,EAAE;YAAEd;UAAM,CAAC,CAAC;QACnD;MACD,CAAA;MACD8P,GAAG,EAAE;QAAEvQ,OAAO,EAAE,WAAW;QAAEmB,UAAU,EAAE;MAAM,CAAA;MAC/CkI,aAAa,EAAE,eAAe,IAAI+G,OAAO,IAAI;QAC3CpQ,OAAO,EAAE,uBAAuB;QAChCmB,UAAU,EAAE;MACd;IACF,CACF,CAAC;GACF;AACH;AAiEO,SAASqP,cAAcA,CAC5BC,QAAoD,EACpDC,YAA2B,EAC3B;EAIA,IAAIC,KAAK,CAACC,OAAO,CAACH,QAAQ,CAAC,EAAE;IAC3B,OAAQI,mBAAwC,IAC9CL,cAAc,CAACK,mBAAmB,EAAEJ,QAAQ,CAAC,CAAC,CAAC,CAAC;EACpD;EAEA,MAAMK,sBAAsB,GAAG,CAAA,CAG9B;EAED,KAAK,MAAMC,UAAU,IAAIhQ,MAAM,CAACd,IAAI,CAACwQ,QAAQ,CAAC,EAAE;IAC9C,MAAMO,QAAQ,GAAIP,QAAQ,CAAyBM,UAAU,CAAC;IAC9D,MAAAE,KAAA,GACE,OAAOD,QAAQ,KAAK,QAAQ,GACxB;QAAErP,OAAO,EAAEA,CAAAA,KAAMqP;MAAS,CAAC,GAC3B,OAAOA,QAAQ,KAAK,UAAU,GAC9B;QAAErP,OAAO,EAAEqP;MAAS,CAAC,GACrBA,QAAQ;MALR;QAAErP;MAAiB,CAAC,GAAAsP,KAAA;MAANC,IAAI,GAAAjB,6BAAA,CAAAgB,KAAA,EAAAE,YAAA,CAAA;IAMxB,MAAMnB,SAAS,GAAG,OAAOrO,OAAO,KAAK,QAAQ,GAAG,MAAMA,OAAO,GAAGA,OAAO;IAEvEmP,sBAAsB,CAACC,UAAU,CAAC,GAAGjB,uBAAuB,CAAA/O,MAAA,CAAAK,MAAA,CAAA;MAC1DQ,IAAI,EAAE/B,cAAc,CAACC,WAAW;MAChCiR,UAAU;MACVf;IAAS,CAAA,EACLU,YAAY,GAAG;MAAEA;IAAa,CAAC,GAAG,CAAE,CAAA,EACrCQ,IAAI,CACR,CAAC;EACJ;EAEA,OAAOJ,sBAAsB;AAC/B;AAWO,MAAMM,MAAM,GAAArQ,MAAA,CAAAK,MAAA,CAAA,CAAA,CAAA,EACdoP,cAAc,CAAC/O,YAAY,CAAC,EAC5B+O,cAAc,CAAC/M,cAAc,CAAC,EAC9B+M,cAAc,CAACpC,gBAAgB,CAAC,EAChCoC,cAAgC,kBAAA,CAACxB,sBAAsB,CAAC,CAC5D;AC9MD,MAAM;EAAEzN;AAAe,CAAC,GAAGR,MAAM;AACjC,MAAMsQ,cAAc,GAAGA,CAAC/Q,MAAW,EAAEC,GAAW,KAC9CgB,cAAc,CAACjB,MAAM,EAAEC,GAAG,EAAE;EAAEY,UAAU,EAAE,KAAK;EAAEV,KAAK,EAAEH,MAAM,CAACC,GAAG;AAAE,CAAC,CAAC;AAExE,SAAS+Q,gBAAgBA,CAACC,IAAS,EAAE;EACnCA,IAAI,CAACpB,GAAG,CAAC7Q,KAAK,IAAI+R,cAAc,CAACE,IAAI,CAACpB,GAAG,CAAC7Q,KAAK,EAAE,OAAO,CAAC;EACzDiS,IAAI,CAACpB,GAAG,CAAC5Q,GAAG,IAAI8R,cAAc,CAACE,IAAI,CAACpB,GAAG,CAAC5Q,GAAG,EAAE,OAAO,CAAC;EAErD,OAAOgS,IAAI;AACb;AAEA,IAAAC,MAAA,GAAgBC,UAAyB,IACvC,MAAMC,iBAAiB,SAASD,UAAU,CAAmB;EAC3DE,KAAKA,CAAAA,EAAS;IACZ,MAAMC,IAAI,GAAGN,gBAAgB,CAAC,KAAK,CAACK,KAAK,CAAE,CAAA,CAAC;IAE5C,IAAI,IAAI,CAACE,OAAO,CAACC,MAAM,EAAE;MACvBF,IAAI,CAACE,MAAM,GAAGF,IAAI,CAACE,MAAM,CAAC9Q,GAAG,CAACsQ,gBAAgB,CAAC;IACjD;IAEA,OAAOM,IAAI;EACb;EAGAG,kBAAkBA,CAAC;IAAEC,OAAO;IAAEC;EAAM,CAAC,EAAyB;IAC5D,IAAIC,KAAoB,GAAG,IAAI;IAC/B,IAAI;MACFA,KAAK,GAAG,IAAIC,MAAM,CAACH,OAAO,EAAEC,KAAK,CAAC;IACpC,CAAC,CAAC,OAAOG,CAAC,EAAE,CAGZ;IACA,MAAMb,IAAI,GAAG,IAAI,CAACc,kBAAkB,CAAwBH,KAAK,CAAC;IAClEX,IAAI,CAACW,KAAK,GAAG;MAAEF,OAAO;MAAEC;KAAO;IAE/B,OAAOV,IAAI;EACb;EAGAe,kBAAkBA,CAAC7R,KAAU,EAAU;IAErC,IAAI8R,MAAqB;IACzB,IAAI;MACFA,MAAM,GAAGC,MAAM,CAAC/R,KAAK,CAAC;IACvB,CAAA,CAAC,OAAAgS,OAAA,EAAM;MACNF,MAAM,GAAG,IAAI;IACf;IACA,MAAMhB,IAAI,GAAG,IAAI,CAACc,kBAAkB,CAAwBE,MAAM,CAAC;IACnEhB,IAAI,CAACmB,MAAM,GAAGlP,MAAM,CAAC+N,IAAI,CAAC9Q,KAAK,IAAIA,KAAK,CAAC;IAEzC,OAAO8Q,IAAI;EACb;EAGAoB,mBAAmBA,CAAClS,KAAU,EAAU;IAGtC,MAAMmS,OAAa,GAAG,IAAI;IAC1B,MAAMrB,IAAI,GAAG,IAAI,CAACc,kBAAkB,CAACO,OAAO,CAAC;IAC7CrB,IAAI,CAACqB,OAAO,GAAGpP,MAAM,CAAC+N,IAAI,CAAC9Q,KAAK,IAAIA,KAAK,CAAC;IAE1C,OAAO8Q,IAAI;EACb;EAEAc,kBAAkBA,CAAmB5R,KAAU,EAAE;IAE/C,OAAO,IAAI,CAACoS,YAAY,CAAIpS,KAAK,EAAE,SAAS,CAAC;EAC/C;EAGAqS,kBAAkBA,CAACrS,KAAU,EAAU;IACrC,OAAO,IAAI,CAAC4R,kBAAkB,CAAC5R,KAAK,CAAC;EACvC;EAEAsS,mBAAmBA,CAACtS,KAAU,EAAO;IACnC,OAAO,IAAI,CAAC4R,kBAAkB,CAAC5R,KAAK,CAAC;EACvC;EAGAuS,gBAAgBA,CAAAA,EAAW;IACzB,OAAO,IAAI,CAACX,kBAAkB,CAAC,IAAI,CAAC;EACtC;EAEAY,mBAAmBA,CAACxS,KAAc,EAAoB;IACpD,OAAO,IAAI,CAAC4R,kBAAkB,CAAC5R,KAAK,CAAC;EACvC;EAGAyS,eAAeA,CAACC,SAAsB,EAAyB;IAC7D,MAAMC,UAAU,GAAGD,SAAS,CAAC1S,KAA+B;IAC5D,OAAO0S,SAAS,CAAC1S,KAAK;IAEtB2S,UAAU,CAAC9P,IAAI,GAAG,SAAS;IAE3B8P,UAAU,CAACC,GAAG,GAAGD,UAAU,CAACE,KAAK,CAACD,GAAG;IACrCD,UAAU,CAAC3S,KAAK,GAAG2S,UAAU,CAACE,KAAK,CAACC,eAAe;IAEnD,MAAMC,IAAI,GAAGL,SAAyC;IACtDK,IAAI,CAAClQ,IAAI,GAAG,qBAAqB;IACjCkQ,IAAI,CAACJ,UAAU,GAAGA,UAAU;IAE5BI,IAAI,CAACL,SAAS,GAAGC,UAAU,CAACE,KAAK,CAACG,QAAQ;IAE1C,OAAOL,UAAU,CAACE,KAAK;IAEvB,OAAOE,IAAI;EACb;EAMAE,YAAYA,CAACnC,IAAoC,EAAEoC,OAAgB,EAAQ;IACzE,KAAK,CAACD,YAAY,CAACnC,IAAI,EAAEoC,OAAO,CAAC;IACjCpC,IAAI,CAAC6B,UAAU,GAAG,KAAK;EACzB;EAEAQ,gBAAgBA,CAACrC,IAAkC,EAAQ;IACzD,IAAIA,IAAI,IAAI,IAAI,IAAI,IAAI,CAACsC,gBAAgB,CAACtC,IAAI,CAAC,EAAE;MAE/C,IAAI,CAACqC,gBAAgB,CAAErC,IAAI,CAAiC9Q,KAAK,CAAC;IACpE,CAAC,MAAM;MACL,KAAK,CAACmT,gBAAgB,CAACrC,IAAI,CAAC;IAC9B;EACF;EAEAuC,4BAA4BA,CAACC,MAAsC,EAAE;IACnE,OAAQA,MAAM,CACXtT,KAAK,CAACuT,MAAM;EACjB;EAEAC,gBAAgBA,CAACT,IAAiB,EAAW;IAAA,IAAAU,qBAAA;IAC3C,OACEV,IAAI,CAAClQ,IAAI,KAAK,qBAAqB,IACnCkQ,IAAI,CAACJ,UAAU,CAAC9P,IAAI,KAAK,SAAS,IAClC,OAAOkQ,IAAI,CAACJ,UAAU,CAAC3S,KAAK,KAAK,QAAQ,IACzC,GAAAyT,qBAAA,GAACV,IAAI,CAACJ,UAAU,CAACE,KAAK,KAArBY,IAAAA,IAAAA,qBAAA,CAAuBC,aAAa,CAAA;EAEzC;EAEAC,cAAcA,CACZ7C,IAA0B,EAC1B8C,eAA2C,EAC3CC,QAAiB,EACjB/U,GAAc,EACdgV,eAA2D,EACrD;IACN,KAAK,CAACH,cAAc,CAClB7C,IAAI,EACJ8C,eAAe,EACfC,QAAQ,EACR/U,GAAG,EACHgV,eACF,CAAC;IAED,MAAMC,mBAAmB,GAAGjD,IAAI,CAACkD,UAAU,CAACzT,GAAG,CAAC0T,CAAC,IAC/C,IAAI,CAACxB,eAAe,CAACwB,CAAC,CACxB,CAAC;IAEDnD,IAAI,CAACoD,IAAI,GAAGH,mBAAmB,CAACI,MAAM,CAACrD,IAAI,CAACoD,IAAI,CAAC;IACjD,OAAOpD,IAAI,CAACkD,UAAU;EACxB;EAEAI,eAAeA,CACbC,SAAsB,EACtBf,MAAqB,EACrBgB,WAAoB,EACpBpB,OAAgB,EAChBqB,aAAsB,EACtBC,iBAA0B,EACpB;IACN,IAAI,CAACC,WAAW,CACdnB,MAAM,EACNgB,WAAW,EACXpB,OAAO,EACPqB,aAAa,EACbC,iBAAiB,EACjB,aAAa,EACb,IACF,CAAC;IACD,IAAIlB,MAAM,CAACoB,cAAc,EAAE;MAEzBpB,MAAM,CAACtT,KAAK,CAAC0U,cAAc,GAAGpB,MAAM,CAACoB,cAAc;MACnD,OAAOpB,MAAM,CAACoB,cAAc;IAC9B;IACAL,SAAS,CAACH,IAAI,CAACS,IAAI,CAACrB,MAAM,CAAC;EAC7B;EAEAsB,gBAAgBA,CAAAA,EAAQ;IACtB,MAAM9D,IAAI,GAAG,KAAK,CAAC8D,gBAAgB,EAAE;IACF;MACjC,IAAI,CAAC,IAAI,CAACC,eAAe,CAAC,QAAQ,EAAE,eAAe,CAAC,EAAE;QACpD,OAAO/D,IAAI;MACb;IACF;IACA,OAAO,IAAI,CAACgE,qCAAqC,CAAChE,IAAI,CAAC;EACzD;EAEAgE,qCAAqCA,CACnChE,IAAmB,EACQ;IAC3B,MAAMjI,IAAI,GAAG,KAAK,CAACkM,gBAAgB,CAACjE,IAAI,CAAC;IACzCA,IAAI,GAAGA,IAAW;IAClB,OAAOA,IAAI,CAACkE,EAAE;IAEdlE,IAAI,CAACjI,IAAI,GAAGA,IAAI;IAEhBiI,IAAI,CAACjO,IAAI,GAAG,mBAAmB;IAC/B,OAAOiO,IAAI;EACb;EAEAmE,aAAaA,CAACnE,IAAY,EAAW;IACA;MACjC,IAAI,CAAC,IAAI,CAAC+D,eAAe,CAAC,QAAQ,EAAE,eAAe,CAAC,EAAE;QACpD,OAAO,KAAK,CAACI,aAAa,CAACnE,IAAI,CAAC;MAClC;IACF;IACA,OAAOA,IAAI,CAACjO,IAAI,KAAK,mBAAmB;EAC1C;EAEAkS,gBAAgBA,CAACjE,IAAY,EAAU;IACF;MACjC,IAAI,CAAC,IAAI,CAAC+D,eAAe,CAAC,QAAQ,EAAE,eAAe,CAAC,EAAE;QACpD,OAAO,KAAK,CAACE,gBAAgB,CAACjE,IAAI,CAAC;MACrC;IACF;IACA,OAAOA,IAAI,CAACjI,IAAI;EAClB;EAGAuJ,YAAYA,CAAsBpS,KAAU,EAAE6C,IAAe,EAAK;IAChE,MAAMiO,IAAI,GAAG,KAAK,CAACsB,YAAY,CAAIpS,KAAK,EAAE6C,IAAI,CAAC;IAE/CiO,IAAI,CAAC8B,GAAG,GAAG9B,IAAI,CAAC+B,KAAK,CAACD,GAAG;IACzB,OAAO9B,IAAI,CAAC+B,KAAK;IAEjB,OAAO/B,IAAI;EACb;EAEAoE,iBAAiBA,CACfpE,IAAgB,EAChBqE,eAAgC,EAChCC,QAAiB,GAAG,KAAK,EACnB;IACN,KAAK,CAACF,iBAAiB,CAACpE,IAAI,EAAEqE,eAAe,EAAEC,QAAQ,CAAC;IACxDtE,IAAI,CAAC6B,UAAU,GAAG7B,IAAI,CAACoD,IAAI,CAACrR,IAAI,KAAK,gBAAgB;EACvD;EAGA4R,WAAWA,CAGT3D,IAAe,EACfwD,WAAoB,EACpBpB,OAAgB,EAChBqB,aAAsB,EACtBc,gBAAyB,EACzBxS,IAAe,EACfyS,YAAqB,GAAG,KAAK,EACH;IAC1B,IAAIC,QAAQ,GAAG,IAAI,CAACC,SAAS,EAAgB;IAC7CD,QAAQ,CAACrS,IAAI,GAAG4N,IAAI,CAAC5N,IAAI;IACzBqS,QAAQ,GAAG,KAAK,CAACd,WAAW,CAE1Bc,QAAQ,EACRjB,WAAW,EACXpB,OAAO,EACPqB,aAAa,EACbc,gBAAgB,EAChBxS,IAAI,EACJyS,YACF,CAAC;IAEDC,QAAQ,CAAC1S,IAAI,GAAG,oBAAoB;IACpC,OAAO0S,QAAQ,CAACrS,IAAI;IAEpB4N,IAAI,CAAC9Q,KAAK,GAAGuV,QAAQ;IACrB,IAAI1S,IAAI,KAAK,oBAAoB,EAAE;MACjCiO,IAAI,CAAC2E,QAAQ,GAAG,KAAK;IACvB;IACA,OAAO,IAAI,CAACC,UAAU,CAEpB5E,IAAI,EACJ,kBACF,CAAC;EACH;EAEA6E,kBAAkBA,CAAC,GAAGC,IAAuB,EAAO;IAClD,MAAMC,YAAY,GAAG,KAAK,CAACF,kBAAkB,CAAC,GAAGC,IAAI,CAAQ;IAC1B;MACjC,IAAI,CAAC,IAAI,CAACf,eAAe,CAAC,QAAQ,EAAE,eAAe,CAAC,EAAE;QACpD,OAAOgB,YAAY;MACrB;IACF;IACAA,YAAY,CAAChT,IAAI,GAAG,oBAAoB;IACxC,OAAOgT,YAAY;EACrB;EAEAC,yBAAyBA,CAAC,GAAGF,IAA8B,EAAO;IAChE,MAAMC,YAAY,GAAG,KAAK,CAACC,yBAAyB,CAAC,GAAGF,IAAI,CAAQ;IACjC;MACjC,IAAI,CAAC,IAAI,CAACf,eAAe,CAAC,QAAQ,EAAE,eAAe,CAAC,EAAE;QACpD,OAAOgB,YAAY;MACrB;IACF;IACAA,YAAY,CAAChT,IAAI,GAAG,oBAAoB;IACxCgT,YAAY,CAACJ,QAAQ,GAAG,KAAK;IAC7B,OAAOI,YAAY;EACrB;EAEAE,iBAAiBA,CACfC,IAAoB,EACpB1B,WAAoB,EACpBpB,OAAgB,EAChB+C,SAAkB,EAClBC,UAAmB,EACgB;IACnC,MAAMpF,IAAsB,GAAG,KAAK,CAACiF,iBAAiB,CACpDC,IAAI,EACJ1B,WAAW,EACXpB,OAAO,EACP+C,SAAS,EACTC,UACF,CAAQ;IAER,IAAIpF,IAAI,EAAE;MACRA,IAAI,CAACjO,IAAI,GAAG,UAAU;MACtB,IAAKiO,IAAI,CAA0B5N,IAAI,KAAK,QAAQ,EAAE;QACpD4N,IAAI,CAAC5N,IAAI,GAAG,MAAM;MACpB;MACA4N,IAAI,CAACqF,SAAS,GAAG,KAAK;IACxB;IAEA,OAAOrF,IAAI;EACb;EAEAsF,mBAAmBA,CACjBJ,IAAsB,EACtBK,QAAqC,EACrCJ,SAAkB,EAClBK,mBAA6C,EACR;IACrC,MAAMxF,IAAsB,GAAG,KAAK,CAACsF,mBAAmB,CACtDJ,IAAI,EACJK,QAAQ,EACRJ,SAAS,EACTK,mBACF,CAAQ;IAER,IAAIxF,IAAI,EAAE;MACRA,IAAI,CAAC5N,IAAI,GAAG,MAAM;MAClB4N,IAAI,CAACjO,IAAI,GAAG,UAAU;IACxB;IAEA,OAAOiO,IAAI;EACb;EAEAyF,WAAWA,CACT1T,IAAY,EACZ2T,yBAAkC,EAClCC,OAAqB,EACrB;IACA,OAAO5T,IAAI,KAAK,UAAU,GACtB,OAAO,GACP,KAAK,CAAC0T,WAAW,CAAC1T,IAAI,EAAE2T,yBAAyB,EAAEC,OAAO,CAAC;EACjE;EAEAC,YAAYA,CAAC5F,IAAY,EAAE6F,SAAmB,EAAW;IACvD,IAAI7F,IAAI,IAAI,IAAI,IAAI,IAAI,CAACsC,gBAAgB,CAACtC,IAAI,CAAC,EAAE;MAC/C,OAAO,IAAI,CAAC4F,YAAY,CAAC5F,IAAI,CAAC9Q,KAAK,EAAE2W,SAAS,CAAC;IACjD;IACA,OAAO,KAAK,CAACD,YAAY,CAAC5F,IAAI,EAAE6F,SAAS,CAAC;EAC5C;EAEAC,YAAYA,CAAC9F,IAAY,EAAE+F,KAAc,GAAG,KAAK,EAAQ;IACvD,IAAI/F,IAAI,IAAI,IAAI,IAAI,IAAI,CAACsC,gBAAgB,CAACtC,IAAI,CAAC,EAAE;MAC/C,MAAM;QAAEhR,GAAG;QAAEE;MAAO,CAAA,GAAG8Q,IAAI;MAC3B,IAAI,IAAI,CAACmE,aAAa,CAACnV,GAAG,CAAC,EAAE;QAC3B,IAAI,CAACgX,UAAU,CAACC,cAAc,CAC5B,IAAI,CAAChC,gBAAgB,CAACjV,GAAG,CAAC,EAC1BA,GAAG,CAAC4P,GAAG,CAAC7Q,KACV,CAAC;MACH;MACA,IAAI,CAAC+X,YAAY,CAAC5W,KAAK,EAAE6W,KAAK,CAAC;IACjC,CAAC,MAAM;MACL,KAAK,CAACD,YAAY,CAAC9F,IAAI,EAAE+F,KAAK,CAAC;IACjC;EACF;EAEAG,gCAAgCA,CAC9BhB,IAAY,EACZiB,MAAe,EACfJ,KAAc,EACd;IACA,IAAIb,IAAI,CAAC9S,IAAI,KAAK,KAAK,IAAI8S,IAAI,CAAC9S,IAAI,KAAK,KAAK,EAAE;MAC9C,IAAI,CAACgU,KAAK,CAACvG,MAAM,CAACtG,kBAAkB,EAAE;QAAE8M,EAAE,EAAEnB,IAAI,CAAClW;MAAI,CAAC,CAAC;IACzD,CAAC,MAAM,IAAIkW,IAAI,CAAC1C,MAAM,EAAE;MACtB,IAAI,CAAC4D,KAAK,CAACvG,MAAM,CAACrG,gBAAgB,EAAE;QAAE6M,EAAE,EAAEnB,IAAI,CAAClW;MAAI,CAAC,CAAC;IACvD,CAAC,MAAM;MACL,KAAK,CAACkX,gCAAgC,CAAChB,IAAI,EAAEiB,MAAM,EAAEJ,KAAK,CAAC;IAC7D;EACF;EAEAO,oBAAoBA,CAClBC,UAAqB,EACrBC,QAAiB,EACd;IACH,MAAMxG,IAAI,GAAG,KAAK,CAACsG,oBAAoB,CAACC,UAAU,EAAEC,QAAQ,CAAC;IAE7D,IAAIxG,IAAI,CAACyG,MAAM,CAAC1U,IAAI,KAAK,QAAQ,EAAE;MAChCiO,IAAI,CAAwCjO,IAAI,GAAG,kBAAkB;MACrEiO,IAAI,CAAwC0G,MAAM,GAAG1G,IAAI,CAAC2G,SAAS,CAAC,CAAC,CAAC;MACvE,IACE,IAAI,CAACC,SAAS,CAAC,kBAAkB,CAAC,IAClC,IAAI,CAACA,SAAS,CAAC,kBAAkB,CAAC,EAClC;QAAA,IAAAC,gBAAA;QACC7G,IAAI,CAAwC8G,UAAU,GAAAD,CAAAA,gBAAA,GACrD7G,IAAI,CAAC2G,SAAS,CAAC,CAAC,CAAC,KAAAE,IAAAA,GAAAA,gBAAA,GAAI,IAAI;MAC7B;MAEA,OAAO7G,IAAI,CAAC2G,SAAS;MAErB,OAAO3G,IAAI,CAACyG,MAAM;IACpB;IAEA,OAAOzG,IAAI;EACb;EAEA+G,qBAAqBA,CACnB/G,IAG4B,EAE5B;IAEA,IAAIA,IAAI,CAACjO,IAAI,KAAK,kBAAkB,EAAE;MACpC;IACF;IAEA,KAAK,CAACgV,qBAAqB,CAAC/G,IAAI,CAAC;EACnC;EAEAgH,WAAWA,CACTT,UAA+B,EAC/BU,UAAgC,EAChC;IACA,MAAMC,cAAc,GAAG,IAAI,CAACC,KAAK,CAACC,eAAe;IACjD,MAAMpH,IAAI,GAAG,KAAK,CAACgH,WAAW,CAACT,UAAU,EAAEU,UAAU,CAAC;IAEtD,QAAQjH,IAAI,CAACjO,IAAI;MACf,KAAK,sBAAsB;QAEzBiO,IAAI,CAACqH,QAAQ,GAAG,IAAI;QACpB;MAEF,KAAK,wBAAwB;QAC3B,IACErH,IAAI,CAACsH,UAAU,CAAC1Y,MAAM,KAAK,CAAC,IAE5BoR,IAAI,CAACsH,UAAU,CAAC,CAAC,CAAC,CAACvV,IAAI,KAAK,0BAA0B,EACtD;UAEAiO,IAAI,CAACjO,IAAI,GAAG,sBAAsB;UAElCiO,IAAI,CAACqH,QAAQ,GAAGrH,IAAI,CAACsH,UAAU,CAAC,CAAC,CAAC,CAACD,QAAQ;UAC3C,OAAOrH,IAAI,CAACsH,UAAU;QACxB;MAGF,KAAK,0BAA0B;QAC7B;UAAA,IAAAC,qBAAA;UACE,MAAM;YAAEC;UAAa,CAAA,GAAGxH,IAAI;UAC5B,IACE,CAAAwH,WAAW,IAAXA,IAAAA,GAAAA,KAAAA,CAAAA,GAAAA,WAAW,CAAEzV,IAAI,MAAK,kBAAkB,IACxC,CAAA,CAAAwV,qBAAA,GAAAC,WAAW,CAACP,UAAU,KAAA,IAAA,GAAA,KAAA,CAAA,GAAtBM,qBAAA,CAAwB3Y,MAAM,IAAG,CAAC,IAElC4Y,WAAW,CAACzZ,KAAK,KAAKiS,IAAI,CAACjS,KAAK,EAChC;YACA,IAAI,CAAC0Z,kBAAkB,CACrBzH,IAAI,EAKJkH,cACF,CAAC;UACH;QACF;QAEA;IACJ;IAEA,OAAOlH,IAAI;EACb;EAEA0H,cAAcA,CACZC,IAAkB,EAClBpC,QAAkB,EAClBqC,OAAmC,EACnCT,KAA4B,EAC5B;IACA,MAAMnH,IAAI,GAAG,KAAK,CAAC0H,cAAc,CAACC,IAAI,EAAEpC,QAAQ,EAAEqC,OAAO,EAAET,KAAK,CAAC;IAEjE,IAAIA,KAAK,CAACU,mBAAmB,EAAE;MAE7B,IACE7H,IAAI,CAACjO,IAAI,KAAK,0BAA0B,IACxCiO,IAAI,CAACjO,IAAI,KAAK,wBAAwB,EACtC;QACAiO,IAAI,CAACjO,IAAI,GAAGiO,IAAI,CAACjO,IAAI,CAAC+V,SAAS,CAAC,CAAC,CAAC;MACpC;MACA,IAAIX,KAAK,CAACY,IAAI,EAAE;QACd,MAAMC,KAAK,GAAG,IAAI,CAACC,eAAe,CAACjI,IAAI,CAAC;QACxCgI,KAAK,CAACnG,UAAU,GAAG7B,IAAI;QACvB,OAAO,IAAI,CAAC4E,UAAU,CAACoD,KAAK,EAAE,iBAAiB,CAAC;MAClD;IACF,CAAC,MAAM,IACLhI,IAAI,CAACjO,IAAI,KAAK,kBAAkB,IAChCiO,IAAI,CAACjO,IAAI,KAAK,gBAAgB,EAC9B;MACAiO,IAAI,CAACwG,QAAQ,GAAG,KAAK;IACvB;IAEA,OAAOxG,IAAI;EACb;EAEAkI,wBAAwBA,CAAClI,IAAY,EAAW;IAC9C,IAAIA,IAAI,CAACjO,IAAI,KAAK,iBAAiB,EAAE;MACnCiO,IAAI,GAAGA,IAAI,CAAC6B,UAAU;IACxB;IACA,OAAO,KAAK,CAACqG,wBAAwB,CAAClI,IAAI,CAAC;EAC7C;EAGAsC,gBAAgBA,CAACtC,IAAY,EAAW;IACtC,OAAOA,IAAI,CAACjO,IAAI,KAAK,UAAU,IAAIiO,IAAI,CAAC5N,IAAI,KAAK,MAAM,IAAI,CAAC4N,IAAI,CAACwC,MAAM;EACzE;EAEA2F,cAAcA,CAACnI,IAAY,EAAW;IACpC,OAAOA,IAAI,CAACwC,MAAM,IAAIxC,IAAI,CAAC5N,IAAI,KAAK,KAAK,IAAI4N,IAAI,CAAC5N,IAAI,KAAK,KAAK;EAClE;EAEAgW,YAAYA,CACVpI,IAAe,EACfjO,IAAe,EACfsW,MAAgB,EACb;IACH,OAAOtI,gBAAgB,CAAC,KAAK,CAACqI,YAAY,CAACpI,IAAI,EAAEjO,IAAI,EAAEsW,MAAM,CAAC,CAAC;EACjE;EAEAZ,kBAAkBA,CAACzH,IAAY,EAAEuF,QAAkB,EAAE;IACnD,KAAK,CAACkC,kBAAkB,CAACzH,IAAI,EAAEuF,QAAQ,CAAC;IACxCxF,gBAAgB,CAACC,IAAI,CAAC;EACxB;EAEAsI,gBAAgBA,CACdtI,IAAc,EACdqI,MAAgB,GAAG,IAAI,CAAClB,KAAK,CAACoB,aAAa,EACrC;IACN,KAAK,CAACD,gBAAgB,CAACtI,IAAI,EAAEqI,MAAM,CAAC;IACpCtI,gBAAgB,CAACC,IAAI,CAAC;EACxB;AACF,CAAC;AC1jBI,MAAMwI,UAAU,CAAC;EACtB/a,WAAWA,CAACqQ,KAAa,EAAE2K,aAAuB,EAAE;IAAA,IAAA,CAKpD3K,KAAK,GAAA,KAAA,CAAA;IAAA,IAAA,CACL2K,aAAa,GAAA,KAAA,CAAA;IALX,IAAI,CAAC3K,KAAK,GAAGA,KAAK;IAClB,IAAI,CAAC2K,aAAa,GAAG,CAAC,CAACA,aAAa;EACtC;AAIF;AAEA,MAAMC,KAEL,GAAG;EACFC,KAAK,EAAE,IAAIH,UAAU,CAAC,GAAG,CAAC;EAC1BI,MAAM,EAAE,IAAIJ,UAAU,CAAC,MAAM,CAAC;EAC9BK,MAAM,EAAE,IAAIL,UAAU,CAAC,OAAO,CAAC;EAC/BM,MAAM,EAAE,IAAIN,UAAU,CAAC,gBAAgB,EAAE,IAAI;AAC/C,CAAC;AAEkC;EACjCE,KAAK,CAACjJ,QAAQ,GAAG,IAAI+I,UAAU,CAAC,GAAG,EAAE,IAAI,CAAC;AAC5C;ACDA,MAAMO,UAAU,GAAG,IAAI;AACvB,MAAMC,UAAU,GAAG,IAAI;AACvB,MAAMC,MAAM,GAAG,IAAI;AACnB,MAAMC,QAAQ,GAAG,IAAI;AACrB,MAAMlX,MAAM,GAAG,IAAI;AACnB,MAAMmX,OAAO,GAAG,IAAI;AAoBb,MAAMC,iBAAiB,CAAC;EAiB7B3b,WAAWA,CAAC4b,KAAa,EAAEC,IAAkB,GAAG,EAAE,EAAE;IAAA,IAAA,CAhBpDD,KAAK,GAAA,KAAA,CAAA;IAAA,IAAA,CACLvO,OAAO,GAAA,KAAA,CAAA;IAAA,IAAA,CACPiO,UAAU,GAAA,KAAA,CAAA;IAAA,IAAA,CACVC,UAAU,GAAA,KAAA,CAAA;IAAA,IAAA,CACVO,gBAAgB,GAAA,KAAA,CAAA;IAAA,IAAA,CAChBN,MAAM,GAAA,KAAA,CAAA;IAAA,IAAA,CACNC,QAAQ,GAAA,KAAA,CAAA;IAAA,IAAA,CACRlX,MAAM,GAAA,KAAA,CAAA;IAAA,IAAA,CACNmX,OAAO,GAAA,KAAA,CAAA;IAAA,IAAA,CACPK,KAAK,GAAA,KAAA,CAAA;IAQH,IAAI,CAACH,KAAK,GAAGA,KAAK;IAClB,IAAI,CAACvO,OAAO,GAAGwO,IAAI,CAACxO,OAAO;IAC3B,IAAI,CAACiO,UAAU,GAAG,CAAC,CAACO,IAAI,CAACP,UAAU;IACnC,IAAI,CAACC,UAAU,GAAG,CAAC,CAACM,IAAI,CAACN,UAAU;IACnC,IAAI,CAACO,gBAAgB,GAAG,CAAC,CAACD,IAAI,CAACC,gBAAgB;IAC/C,IAAI,CAACN,MAAM,GAAG,CAAC,CAACK,IAAI,CAACL,MAAM;IAC3B,IAAI,CAACC,QAAQ,GAAG,CAAC,CAACI,IAAI,CAACJ,QAAQ;IAC/B,IAAI,CAAClX,MAAM,GAAG,CAAC,CAACsX,IAAI,CAACtX,MAAM;IAC3B,IAAI,CAACmX,OAAO,GAAG,CAAC,CAACG,IAAI,CAACH,OAAO;IAC7B,IAAI,CAACK,KAAK,GAAGF,IAAI,CAACE,KAAK,IAAI,IAAI,GAAGF,IAAI,CAACE,KAAK,GAAG,IAAI;IAChB;MACjC,IAAI,CAACC,aAAa,GAAG,IAAI;IAC3B;EACF;AACF;AAGO,MAAMC,UAAQ,GAAG,IAAIC,GAAG,EAAqB;AAEpD,SAASC,aAAaA,CAAC7R,IAAY,EAAEuI,OAAqB,GAAG,EAAE,EAAa;EAC1EA,OAAO,CAACxF,OAAO,GAAG/C,IAAI;EACtB,MAAM+F,KAAK,GAAG+L,WAAW,CAAC9R,IAAI,EAAEuI,OAAO,CAAC;EACxCoJ,UAAQ,CAACza,GAAG,CAAC8I,IAAI,EAAE+F,KAAK,CAAC;EACzB,OAAOA,KAAK;AACd;AAEA,SAASgM,WAAWA,CAAC/R,IAAY,EAAEyR,KAAa,EAAE;EAChD,OAAOK,WAAW,CAAC9R,IAAI,EAAE;IAAEgR,UAAU;IAAES;EAAM,CAAC,CAAC;AACjD;AAEA,IAAIO,gBAAgB,GAAG,CAAC,CAAC;AAClB,MAAMC,UAA+B,GAAG,EAAE;AACjD,MAAMC,WAAqB,GAAG,EAAE;AAChC,MAAMC,WAAqB,GAAG,EAAE;AAChC,MAAMC,gBAA2B,GAAG,EAAE;AACtC,MAAMC,gBAA2B,GAAG,EAAE;AACtC,MAAMC,aAAwB,GAAG,EAAE;AAEnC,SAASR,WAAWA,CAAC9R,IAAY,EAAEuI,OAAqB,GAAG,EAAE,EAAa;EAAA,IAAAgK,cAAA,EAAAC,mBAAA,EAAAC,mBAAA,EAAAC,eAAA;EACxE,EAAEV,gBAAgB;EAClBE,WAAW,CAACpG,IAAI,CAAC9L,IAAI,CAAC;EACtBmS,WAAW,CAACrG,IAAI,CAAAyG,CAAAA,cAAA,GAAChK,OAAO,CAACkJ,KAAK,KAAAc,IAAAA,GAAAA,cAAA,GAAI,CAAC,CAAC,CAAC;EACrCH,gBAAgB,CAACtG,IAAI,CAAA0G,CAAAA,mBAAA,GAACjK,OAAO,CAACyI,UAAU,KAAAwB,IAAAA,GAAAA,mBAAA,GAAI,KAAK,CAAC;EAClDH,gBAAgB,CAACvG,IAAI,CAAA2G,CAAAA,mBAAA,GAAClK,OAAO,CAAC0I,UAAU,KAAAwB,IAAAA,GAAAA,mBAAA,GAAI,KAAK,CAAC;EAClDH,aAAa,CAACxG,IAAI,CAAA4G,CAAAA,eAAA,GAACnK,OAAO,CAACtO,MAAM,KAAAyY,IAAAA,GAAAA,eAAA,GAAI,KAAK,CAAC;EAC3CT,UAAU,CAACnG,IAAI,CAAC,IAAIuF,iBAAiB,CAACrR,IAAI,EAAEuI,OAAO,CAAC,CAAC;EAErD,OAAOyJ,gBAAgB;AACzB;AAEA,SAASW,iBAAiBA,CACxB3S,IAAY,EACZuI,OAAqB,GAAG,EAAE,EACf;EAAA,IAAAqK,eAAA,EAAAC,oBAAA,EAAAC,oBAAA,EAAAC,gBAAA;EACX,EAAEf,gBAAgB;EAClBL,UAAQ,CAACza,GAAG,CAAC8I,IAAI,EAAEgS,gBAAgB,CAAC;EACpCE,WAAW,CAACpG,IAAI,CAAC9L,IAAI,CAAC;EACtBmS,WAAW,CAACrG,IAAI,CAAA8G,CAAAA,eAAA,GAACrK,OAAO,CAACkJ,KAAK,KAAAmB,IAAAA,GAAAA,eAAA,GAAI,CAAC,CAAC,CAAC;EACrCR,gBAAgB,CAACtG,IAAI,CAAA+G,CAAAA,oBAAA,GAACtK,OAAO,CAACyI,UAAU,KAAA6B,IAAAA,GAAAA,oBAAA,GAAI,KAAK,CAAC;EAClDR,gBAAgB,CAACvG,IAAI,CAAAgH,CAAAA,oBAAA,GAACvK,OAAO,CAAC0I,UAAU,KAAA6B,IAAAA,GAAAA,oBAAA,GAAI,KAAK,CAAC;EAClDR,aAAa,CAACxG,IAAI,CAAAiH,CAAAA,gBAAA,GAACxK,OAAO,CAACtO,MAAM,KAAA8Y,IAAAA,GAAAA,gBAAA,GAAI,KAAK,CAAC;EAE3Cd,UAAU,CAACnG,IAAI,CAAC,IAAIuF,iBAAiB,CAAC,MAAM,EAAE9I,OAAO,CAAC,CAAC;EAEvD,OAAOyJ,gBAAgB;AACzB;AAOO,MAAMgB,EAAE,GAAG;EAEhBC,QAAQ,EAAEnB,WAAW,CAAC,GAAG,EAAE;IAAEd,UAAU;IAAEC;EAAW,CAAC,CAAC;EACtDiC,YAAY,EAAEpB,WAAW,CAAC,IAAI,EAAE;IAAEd,UAAU;IAAEC;EAAW,CAAC,CAAC;EAC3DkC,WAAW,EAAErB,WAAW,CAAC,IAAI,EAAE;IAAEd,UAAU;IAAEC;EAAW,CAAC,CAAC;EAC1DmC,QAAQ,EAAEtB,WAAW,CAAC,GAAG,CAAC;EAC1BuB,WAAW,EAAEvB,WAAW,CAAC,IAAI,CAAC;EAC9BwB,MAAM,EAAExB,WAAW,CAAC,GAAG,EAAE;IAAEd,UAAU;IAAEC;EAAW,CAAC,CAAC;EACpDsC,SAAS,EAAEzB,WAAW,CAAC,IAAI,EAAE;IAAEd,UAAU;IAAEC;EAAW,CAAC,CAAC;EACxDuC,UAAU,EAAE1B,WAAW,CAAC,IAAI,EAAE;IAAEd,UAAU;IAAEC;EAAW,CAAC,CAAC;EACzDwC,MAAM,EAAE3B,WAAW,CAAC,GAAG,CAAC;EACxB4B,SAAS,EAAE5B,WAAW,CAAC,IAAI,CAAC;EAC5B6B,MAAM,EAAE7B,WAAW,CAAC,GAAG,EAAE;IAAEd,UAAU;IAAEC;EAAW,CAAC,CAAC;EACpD2C,MAAM,EAAE9B,WAAW,CAAC,GAAG,CAAC;EACxB+B,KAAK,EAAE/B,WAAW,CAAC,GAAG,EAAE;IAAEd;EAAW,CAAC,CAAC;EACvC8C,IAAI,EAAEhC,WAAW,CAAC,GAAG,EAAE;IAAEd;EAAW,CAAC,CAAC;EACtC+C,KAAK,EAAEjC,WAAW,CAAC,GAAG,EAAE;IAAEd;EAAW,CAAC,CAAC;EACvCgD,WAAW,EAAElC,WAAW,CAAC,IAAI,EAAE;IAAEd;EAAW,CAAC,CAAC;EAC9CiD,GAAG,EAAEnC,WAAW,CAAC,GAAG,CAAC;EACrBoC,QAAQ,EAAEpC,WAAW,CAAC,GAAG,EAAE;IAAEd;EAAW,CAAC,CAAC;EAC1CmD,WAAW,EAAErC,WAAW,CAAC,IAAI,CAAC;EAC9BsC,KAAK,EAAEtC,WAAW,CAAC,IAAI,EAAE;IAAEd;EAAW,CAAC,CAAC;EACxCtJ,QAAQ,EAAEoK,WAAW,CAAC,UAAU,CAAC;EACjCuC,QAAQ,EAAEvC,WAAW,CAAC,KAAK,EAAE;IAAEd;EAAW,CAAC,CAAC;EAC5CsD,SAAS,EAAExC,WAAW,CAAC,GAAG,EAAE;IAAEb;EAAW,CAAC,CAAC;EAC3CsD,YAAY,EAAEzC,WAAW,CAAC,IAAI,EAAE;IAAEd,UAAU;IAAEC;EAAW,CAAC,CAAC;EAE3DuD,YAAY,EAAE1C,WAAW,CAAC,MAAM,EAAE;IAAEb;EAAW,CAAC,CAAC;EACjDwD,eAAe,EAAE3C,WAAW,CAAC,OAAO,EAAE;IAAEd,UAAU;IAAEC;EAAW,CAAC,CAAC;EAEjE3C,EAAE,EAAEwD,WAAW,CAAC,GAAG,CAAC;EACpB4C,IAAI,EAAE5C,WAAW,CAAC,GAAG,EAAE;IAAEb;EAAW,CAAC,CAAC;EAGtC0D,oBAAoB,EAAE7C,WAAW,CAAC,OAAO,CAAC;EAiB1C8C,EAAE,EAAE9C,WAAW,CAAC,GAAG,EAAE;IAAEd,UAAU;IAAEG;EAAS,CAAC,CAAC;EAC9CrZ,MAAM,EAAEga,WAAW,CAAC,IAAI,EAAE;IAAEd,UAAU;IAAEG;EAAS,CAAC,CAAC;EACnD0D,WAAW,EAAE/C,WAAW,CAAC,IAAI,EAAE;IAAEd,UAAU;IAAEG;EAAS,CAAC,CAAC;EAIxD2D,SAAS,EAAEhD,WAAW,CAAC,IAAI,EAAE;IAAEd,UAAU;IAAEG;EAAS,CAAC,CAAC;EACtD4D,YAAY,EAAEjD,WAAW,CAAC,IAAI,EAAE;IAAEd,UAAU;IAAEG;EAAS,CAAC,CAAC;EAGzD6D,MAAM,EAAElD,WAAW,CAAC,OAAO,EAAE;IAAE7X,MAAM;IAAEmX,OAAO;IAAEH;EAAW,CAAC,CAAC;EAC7DgE,IAAI,EAAEnD,WAAW,CAAC,GAAG,EAAE;IAAEd,UAAU;IAAE/W,MAAM;IAAEgX;EAAW,CAAC,CAAC;EAC1DiE,KAAK,EAAEpD,WAAW,CAAC,GAAG,EAAE;IAAEd,UAAU;IAAE/W,MAAM;IAAEgX;EAAW,CAAC,CAAC;EAI3DkE,WAAW,EAAErD,WAAW,CAAC,IAAI,EAAE;IAAEb;EAAW,CAAC,CAAC;EAC9CmE,QAAQ,EAAEtD,WAAW,CAAC,IAAI,EAAE;IAAEb;EAAW,CAAC,CAAC;EAG3CoE,QAAQ,EAAEtD,WAAW,CAAC,IAAI,EAAE,CAAC,CAAC;EAC9BuD,iBAAiB,EAAEvD,WAAW,CAAC,IAAI,EAAE,CAAC,CAAC;EACvCwD,SAAS,EAAExD,WAAW,CAAC,IAAI,EAAE,CAAC,CAAC;EAC/ByD,UAAU,EAAEzD,WAAW,CAAC,IAAI,EAAE,CAAC,CAAC;EAChC0D,SAAS,EAAE1D,WAAW,CAAC,GAAG,EAAE,CAAC,CAAC;EAC9B2D,UAAU,EAAE3D,WAAW,CAAC,GAAG,EAAE,CAAC,CAAC;EAC/B4D,UAAU,EAAE5D,WAAW,CAAC,GAAG,EAAE,CAAC,CAAC;EAC/B6D,QAAQ,EAAE7D,WAAW,CAAC,eAAe,EAAE,CAAC,CAAC;EACzC8D,EAAE,EAAE9D,WAAW,CAAC,WAAW,EAAE,CAAC,CAAC;EAC/B+D,EAAE,EAAE/D,WAAW,CAAC,WAAW,EAAE,CAAC,CAAC;EAC/BgE,UAAU,EAAEhE,WAAW,CAAC,WAAW,EAAE,CAAC,CAAC;EACvCiE,QAAQ,EAAEjE,WAAW,CAAC,WAAW,EAAE,CAAC,CAAC;EACrCkE,SAAS,EAAElE,WAAW,CAAC,WAAW,EAAE,CAAC,CAAC;EACtCmE,SAAS,EAAEnE,WAAW,CAAC,WAAW,EAAE,CAAC,CAAC;EACtCoE,OAAO,EAAErE,WAAW,CAAC,KAAK,EAAE;IAAEd,UAAU;IAAES,KAAK,EAAE,CAAC;IAAExX,MAAM;IAAEgX;EAAW,CAAC,CAAC;EAEzEmF,MAAM,EAAEtE,WAAW,CAAC,GAAG,EAAE;IAAEL,KAAK,EAAE,EAAE;IAAER;EAAW,CAAC,CAAC;EAEnDoF,IAAI,EAAEvE,WAAW,CAAC,GAAG,EAAE;IAAEL,KAAK,EAAE;EAAG,CAAC,CAAC;EACrC6E,KAAK,EAAEvE,WAAW,CAAC,GAAG,EAAE,EAAE,CAAC;EAC3BwE,QAAQ,EAAEzE,WAAW,CAAC,IAAI,EAAE;IAC1Bd,UAAU;IACVS,KAAK,EAAE,EAAE;IACTD,gBAAgB,EAAE;EACpB,CAAC,CAAC;EAOFgF,GAAG,EAAE3E,aAAa,CAAC,IAAI,EAAE;IAAEb,UAAU;IAAES,KAAK,EAAE;EAAE,CAAC,CAAC;EAClDgF,WAAW,EAAE5E,aAAa,CAAC,YAAY,EAAE;IAAEb,UAAU;IAAES,KAAK,EAAE;EAAE,CAAC,CAAC;EAElEiF,MAAM,EAAE7E,aAAa,CAAC,OAAO,CAAC;EAC9B8E,KAAK,EAAE9E,aAAa,CAAC,MAAM,EAAE;IAAEb;EAAW,CAAC,CAAC;EAC5C4F,MAAM,EAAE/E,aAAa,CAAC,OAAO,CAAC;EAC9BgF,SAAS,EAAEhF,aAAa,CAAC,UAAU,CAAC;EACpCiF,SAAS,EAAEjF,aAAa,CAAC,UAAU,CAAC;EACpCkF,QAAQ,EAAElF,aAAa,CAAC,SAAS,EAAE;IAAEb;EAAW,CAAC,CAAC;EAClDgG,KAAK,EAAEnF,aAAa,CAAC,MAAM,EAAE;IAAEb;EAAW,CAAC,CAAC;EAC5CiG,QAAQ,EAAEpF,aAAa,CAAC,SAAS,CAAC;EAClCqF,SAAS,EAAErF,aAAa,CAAC,UAAU,EAAE;IAAEZ;EAAW,CAAC,CAAC;EACpDkG,GAAG,EAAEtF,aAAa,CAAC,IAAI,CAAC;EACxBuF,OAAO,EAAEvF,aAAa,CAAC,QAAQ,EAAE;IAAEb;EAAW,CAAC,CAAC;EAChDqG,OAAO,EAAExF,aAAa,CAAC,QAAQ,CAAC;EAChCyF,MAAM,EAAEzF,aAAa,CAAC,OAAO,EAAE;IAAEb,UAAU;IAAE/W,MAAM;IAAEgX;EAAW,CAAC,CAAC;EAClEsG,IAAI,EAAE1F,aAAa,CAAC,KAAK,CAAC;EAC1B2F,IAAI,EAAE3F,aAAa,CAAC,KAAK,CAAC;EAC1B4F,MAAM,EAAE5F,aAAa,CAAC,OAAO,CAAC;EAC9B6F,KAAK,EAAE7F,aAAa,CAAC,MAAM,CAAC;EAC5B8F,IAAI,EAAE9F,aAAa,CAAC,KAAK,EAAE;IAAEb,UAAU;IAAEC;EAAW,CAAC,CAAC;EACtD2G,KAAK,EAAE/F,aAAa,CAAC,MAAM,EAAE;IAAEZ;EAAW,CAAC,CAAC;EAC5C4G,MAAM,EAAEhG,aAAa,CAAC,OAAO,EAAE;IAAEZ;EAAW,CAAC,CAAC;EAC9C6G,MAAM,EAAEjG,aAAa,CAAC,OAAO,EAAE;IAAEZ;EAAW,CAAC,CAAC;EAC9C8G,QAAQ,EAAElG,aAAa,CAAC,SAAS,EAAE;IAAEb;EAAW,CAAC,CAAC;EAClDgH,OAAO,EAAEnG,aAAa,CAAC,QAAQ,CAAC;EAChCoG,OAAO,EAAEpG,aAAa,CAAC,QAAQ,EAAE;IAAEZ;EAAW,CAAC,CAAC;EAChDiH,KAAK,EAAErG,aAAa,CAAC,MAAM,EAAE;IAAEZ;EAAW,CAAC,CAAC;EAC5CkH,KAAK,EAAEtG,aAAa,CAAC,MAAM,EAAE;IAAEZ;EAAW,CAAC,CAAC;EAC5CmH,MAAM,EAAEvG,aAAa,CAAC,OAAO,EAAE;IAAEZ;EAAW,CAAC,CAAC;EAC9CoH,OAAO,EAAExG,aAAa,CAAC,QAAQ,EAAE;IAAEb,UAAU;IAAE/W,MAAM;IAAEgX;EAAW,CAAC,CAAC;EACpEqH,KAAK,EAAEzG,aAAa,CAAC,MAAM,EAAE;IAAEb,UAAU;IAAE/W,MAAM;IAAEgX;EAAW,CAAC,CAAC;EAChEsH,OAAO,EAAE1G,aAAa,CAAC,QAAQ,EAAE;IAAEb,UAAU;IAAE/W,MAAM;IAAEgX;EAAW,CAAC,CAAC;EAEpEuH,GAAG,EAAE3G,aAAa,CAAC,IAAI,EAAE;IAAEX,MAAM;IAAEF;EAAW,CAAC,CAAC;EAChDyH,IAAI,EAAE5G,aAAa,CAAC,KAAK,EAAE;IAAEX;EAAO,CAAC,CAAC;EACtCwH,MAAM,EAAE7G,aAAa,CAAC,OAAO,EAAE;IAAEX;EAAO,CAAC,CAAC;EAM1CyH,GAAG,EAAEhG,iBAAiB,CAAC,IAAI,EAAE;IAAE1B;EAAW,CAAC,CAAC;EAC5C2H,OAAO,EAAEjG,iBAAiB,CAAC,QAAQ,EAAE;IAAE1B;EAAW,CAAC,CAAC;EACpD4H,MAAM,EAAElG,iBAAiB,CAAC,OAAO,EAAE;IAAE1B;EAAW,CAAC,CAAC;EAClD6H,MAAM,EAAEnG,iBAAiB,CAAC,OAAO,EAAE;IAAE1B;EAAW,CAAC,CAAC;EAClD8H,KAAK,EAAEpG,iBAAiB,CAAC,MAAM,EAAE;IAAE1B;EAAW,CAAC,CAAC;EAChD+H,IAAI,EAAErG,iBAAiB,CAAC,KAAK,EAAE;IAAE1B;EAAW,CAAC,CAAC;EAC9CgI,IAAI,EAAEtG,iBAAiB,CAAC,KAAK,EAAE;IAAE1B;EAAW,CAAC,CAAC;EAC9CiI,KAAK,EAAEvG,iBAAiB,CAAC,MAAM,EAAE;IAAE1B;EAAW,CAAC,CAAC;EAChDkI,GAAG,EAAExG,iBAAiB,CAAC,IAAI,EAAE;IAAE1B;EAAW,CAAC,CAAC;EAC5CmI,KAAK,EAAEzG,iBAAiB,CAAC,MAAM,EAAE;IAAE1B;EAAW,CAAC,CAAC;EAChDoI,IAAI,EAAE1G,iBAAiB,CAAC,KAAK,EAAE;IAAE1B;EAAW,CAAC,CAAC;EAC9CqI,OAAO,EAAE3G,iBAAiB,CAAC,QAAQ,EAAE;IAAE1B;EAAW,CAAC,CAAC;EACpDsI,MAAM,EAAE5G,iBAAiB,CAAC,OAAO,EAAE;IAAE1B;EAAW,CAAC,CAAC;EAClDuI,MAAM,EAAE7G,iBAAiB,CAAC,OAAO,EAAE;IAAE1B;EAAW,CAAC,CAAC;EAGlDwI,QAAQ,EAAE9G,iBAAiB,CAAC,SAAS,EAAE;IAAE1B;EAAW,CAAC,CAAC;EACtDyI,OAAO,EAAE/G,iBAAiB,CAAC,QAAQ,EAAE;IAAE1B;EAAW,CAAC,CAAC;EACpD0I,QAAQ,EAAEhH,iBAAiB,CAAC,SAAS,EAAE;IAAE1B;EAAW,CAAC,CAAC;EACtD2I,OAAO,EAAEjH,iBAAiB,CAAC,QAAQ,EAAE;IAAE1B;EAAW,CAAC,CAAC;EACpD4I,WAAW,EAAElH,iBAAiB,CAAC,YAAY,EAAE;IAAE1B;EAAW,CAAC,CAAC;EAC5D6I,UAAU,EAAEnH,iBAAiB,CAAC,WAAW,EAAE;IAAE1B;EAAW,CAAC,CAAC;EAC1D8I,MAAM,EAAEpH,iBAAiB,CAAC,OAAO,EAAE;IAAE1B;EAAW,CAAC,CAAC;EAClD+I,GAAG,EAAErH,iBAAiB,CAAC,IAAI,EAAE;IAAE1B;EAAW,CAAC,CAAC;EAC5CgJ,OAAO,EAAEtH,iBAAiB,CAAC,QAAQ,EAAE;IAAE1B;EAAW,CAAC,CAAC;EACpDiJ,MAAM,EAAEvH,iBAAiB,CAAC,OAAO,EAAE;IAAE1B;EAAW,CAAC,CAAC;EAClDkJ,QAAQ,EAAExH,iBAAiB,CAAC,SAAS,EAAE;IAAE1B;EAAW,CAAC,CAAC;EACtDmJ,UAAU,EAAEzH,iBAAiB,CAAC,WAAW,EAAE;IAAE1B;EAAW,CAAC,CAAC;EAE1DoJ,MAAM,EAAE1H,iBAAiB,CAAC,OAAO,EAAE;IAAE1B;EAAW,CAAC,CAAC;EAClDqJ,SAAS,EAAE3H,iBAAiB,CAAC,UAAU,EAAE;IAAE1B;EAAW,CAAC,CAAC;EACxDsJ,OAAO,EAAE5H,iBAAiB,CAAC,QAAQ,EAAE;IAAE1B;EAAW,CAAC,CAAC;EAGpDuJ,SAAS,EAAE7H,iBAAiB,CAAC,UAAU,EAAE;IAAE1B;EAAW,CAAC,CAAC;EACxDwJ,QAAQ,EAAE9H,iBAAiB,CAAC,SAAS,EAAE;IAAE1B;EAAW,CAAC,CAAC;EACtDyJ,KAAK,EAAE/H,iBAAiB,CAAC,MAAM,EAAE;IAAE1B;EAAW,CAAC,CAAC;EAChD0J,OAAO,EAAEhI,iBAAiB,CAAC,QAAQ,EAAE;IAAE1B;EAAW,CAAC,CAAC;EACpD2J,UAAU,EAAEjI,iBAAiB,CAAC,WAAW,EAAE;IAAE1B;EAAW,CAAC,CAAC;EAE1D4J,UAAU,EAAElI,iBAAiB,CAAC,WAAW,EAAE;IAAE1B;EAAW,CAAC,CAAC;EAC1D6J,KAAK,EAAEnI,iBAAiB,CAAC,MAAM,EAAE;IAAE1B;EAAW,CAAC,CAAC;EAEhD8J,OAAO,EAAEpI,iBAAiB,CAAC,QAAQ,EAAE;IAAE1B;EAAW,CAAC,CAAC;EAEpDjR,IAAI,EAAE8R,WAAW,CAAC,MAAM,EAAE;IAAEb;EAAW,CAAC,CAAC;EAGzC+J,MAAM,EAAElJ,WAAW,CAAC,QAAQ,EAAE;IAAEb;EAAW,CAAC,CAAC;EAC7CgK,GAAG,EAAEnJ,WAAW,CAAC,KAAK,EAAE;IAAEb;EAAW,CAAC,CAAC;EACvC7H,MAAM,EAAE0I,WAAW,CAAC,QAAQ,EAAE;IAAEb;EAAW,CAAC,CAAC;EAC7C3H,OAAO,EAAEwI,WAAW,CAAC,SAAS,EAAE;IAAEb;EAAW,CAAC,CAAC;EAE/CiK,MAAM,EAAEpJ,WAAW,CAAC,QAAQ,EAAE;IAAEb;EAAW,CAAC,CAAC;EAC7CkK,WAAW,EAAErJ,WAAW,CAAC,OAAO,EAAE;IAAEb;EAAW,CAAC,CAAC;EACjDmK,GAAG,EAAEtJ,WAAW,CAAC,KAAK,CAAC;EAGvBuJ,OAAO,EAAEvJ,WAAW,CAAC,SAAS,CAAC;EAC/BwJ,OAAO,EAAExJ,WAAW,CAAC,SAAS,EAAE;IAAEd,UAAU,EAAE;EAAK,CAAC,CAAC;EACrDuK,WAAW,EAAEzJ,WAAW,CAAC,aAAa,EAAE;IAAEb,UAAU,EAAE;EAAK,CAAC,CAAC;EAC7DuK,SAAS,EAAE1J,WAAW,CAAC,WAAW,CAAC;EAGnC2J,WAAW,EAAE3J,WAAW,CAAC,IAAI,EAAE;IAAEb,UAAU,EAAE;GAAM;AACrD,CAAU;AAEH,SAASyK,iBAAiBA,CAAC3V,KAAgB,EAAW;EAC3D,OAAOA,KAAK,IAAA,EAAU,IAAIA,KAAK,IAAW,GAAA;AAC5C;AAEO,SAAS4V,iCAAiCA,CAAC5V,KAAgB,EAAW;EAG3E,OAAOA,KAAK,IAAa,EAAA;AAC3B;AAEO,SAAS6V,0BAA0BA,CAAC7V,KAAgB,EAAW;EACpE,OAAOA,KAAK,IAAA,EAAU,IAAIA,KAAK,IAAW,GAAA;AAC5C;AAEO,SAAS8V,0BAA0BA,CAAC9V,KAAgB,EAAW;EACpE,OAAOA,KAAK,IAAA,EAAU,IAAIA,KAAK,IAAc,GAAA;AAC/C;AAEO,SAAS+V,0BAA0BA,CAAC/V,KAAgB,EAAW;EACpE,OAAOqM,gBAAgB,CAACrM,KAAK,CAAC;AAChC;AAEO,SAASgW,uBAAuBA,CAAChW,KAAgB,EAAW;EACjE,OAAOsM,gBAAgB,CAACtM,KAAK,CAAC;AAChC;AAEO,SAASiW,iBAAiBA,CAACjW,KAAgB,EAAW;EAC3D,OAAOA,KAAK,IAAA,EAAS,IAAIA,KAAK,IAAmB,EAAA;AACnD;AAEO,SAASkW,kCAAkCA,CAAClW,KAAgB,EAAW;EAC5E,OAAOA,KAAK,IAAA,GAAiB,IAAIA,KAAK,IAAc,GAAA;AACtD;AAEO,SAASmW,WAAWA,CAACnW,KAAgB,EAAW;EACrD,OAAOA,KAAK,IAAA,EAAU,IAAIA,KAAK,IAAa,EAAA;AAC9C;AAEO,SAASoW,cAAcA,CAACpW,KAAgB,EAAW;EACxD,OAAOA,KAAK,IAAA,EAAU,IAAIA,KAAK,IAAa,EAAA;AAC9C;AAEO,SAASqW,eAAeA,CAACrW,KAAgB,EAAW;EACzD,OAAOA,KAAK,IAAA,EAAe,IAAIA,KAAK,IAAkB,EAAA;AACxD;AAEO,SAASsW,cAAcA,CAACtW,KAAgB,EAAW;EACxD,OAAOA,KAAK,KAAc,EAAA;AAC5B;AAEO,SAASuW,aAAaA,CAACvW,KAAgB,EAAW;EACvD,OAAOuM,aAAa,CAACvM,KAAK,CAAC;AAC7B;AAEO,SAASwW,qBAAqBA,CAACxW,KAAgB,EAAW;EAC/D,OAAOA,KAAK,IAAA,GAAa,IAAIA,KAAK,IAAc,GAAA;AAClD;AAEO,SAASyW,yBAAyBA,CAACzW,KAAgB,EAAW;EACnE,OAAOA,KAAK,IAAA,GAAgB,IAAIA,KAAK,IAAY,GAAA;AACnD;AAEO,SAAS0W,cAAcA,CAAC1W,KAAgB,EAAU;EACvD,OAAOmM,WAAW,CAACnM,KAAK,CAAC;AAC3B;AAEO,SAAS2W,uBAAuBA,CAAC3W,KAAgB,EAAU;EAChE,OAAOoM,WAAW,CAACpM,KAAK,CAAC;AAC3B;AAMO,SAAS4W,uBAAuBA,CAAC5W,KAAgB,EAAW;EACjE,OAAOA,KAAK,KAAgB,EAAA;AAC9B;AAEO,SAAS6W,eAAeA,CAAC7W,KAAgB,EAAW;EACzD,OAAOA,KAAK,IAAA,EAAmB,IAAIA,KAAK,IAAsB,EAAA;AAChE;AAEO,SAAS8W,gBAAgBA,CAAC9W,KAAgB,EAAqB;EACpE,OAAOkM,UAAU,CAAClM,KAAK,CAAC;AAC1B;AAMmC;EACjCkM,UAAU,CAAW,CAAA,CAAA,CAACP,aAAa,GAAGoL,OAAO,IAAI;IAC/CA,OAAO,CAACC,GAAG,CAAA,CAAE;GACd;EAED9K,UAAU,CAAW,CAAA,CAAA,CAACP,aAAa,GACjCO,UAAU,CAAe,CAAA,CAAA,CAACP,aAAa,GACvCO,UAAU,CAAiB,EAAA,CAAA,CAACP,aAAa,GACvCoL,OAAO,IAAI;IACTA,OAAO,CAAChR,IAAI,CAACkR,KAAE,CAACpM,KAAK,CAAC;GACvB;EAELqB,UAAU,CAAc,EAAA,CAAA,CAACP,aAAa,GAAGoL,OAAO,IAAI;IAClD,IAAIA,OAAO,CAACA,OAAO,CAACjmB,MAAM,GAAG,CAAC,CAAC,KAAKmmB,KAAE,CAACtV,QAAQ,EAAE;MAC/CoV,OAAO,CAACC,GAAG,CAAA,CAAE;IACf,CAAC,MAAM;MACLD,OAAO,CAAChR,IAAI,CAACkR,KAAE,CAACtV,QAAQ,CAAC;IAC3B;GACD;EAEDuK,UAAU,CAAgB,GAAA,CAAA,CAACP,aAAa,GAAGoL,OAAO,IAAI;IACpDA,OAAO,CAAChR,IAAI,CAACkR,KAAE,CAACjM,MAAM,EAAEiM,KAAE,CAACnM,MAAM,CAAC;GACnC;AACH;ACncA,IAAIoM,4BAA4B,GAAG,8qIAA8qI;AAEjtI,IAAIC,uBAAuB,GAAG,mkFAAmkF;AAEjmF,MAAMC,uBAAuB,GAAG,IAAItU,MAAM,CACxC,GAAG,GAAGoU,4BAA4B,GAAG,GACvC,CAAC;AACD,MAAMG,kBAAkB,GAAG,IAAIvU,MAAM,CACnC,GAAG,GAAGoU,4BAA4B,GAAGC,uBAAuB,GAAG,GACjE,CAAC;AAEDD,4BAA4B,GAAGC,uBAAu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j+C,MAAMC,qBAAqB,GAAG,CAAC,GAAG,EAAC,CAAC,EAAC,GAAG,EAAC,CAAC,EAAC,GAAG,EAAC,CAAC,EAAC,GAAG,EAAC,CAAC,EAAC,IAAI,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,EAAE,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,GAAG,EAAC,CAAC,EAAC,GAAG,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,GAAG,EAAC,CAAC,EAAC,EAAE,EAAC,CAAC,EAAC,EAAE,EAAC,EAAE,EAAC,EAAE,EAAC,CAAC,EAAC,GAAG,EAAC,CAAC,EAAC,EAAE,EAAC,EAAE,EAAC,EAAE,EAAC,EAAE,EAAC,CAAC,EAAC,CAAC,EAAC,EAAE,EAAC,CAAC,EAAC,EAAE,EAAC,EAAE,EAAC,CAAC,EAAC,CAAC,EAAC,EAAE,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,EAAE,EAAC,EAAE,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,EAAE,EAAC,CAAC,EAAC,EAAE,EAAC,CAAC,EAAC,EAAE,EAAC,EAAE,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,EAAE,EAAC,EAAE,EAAC,EAAE,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,GAAG,EAAC,EAAE,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,EAAE,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,EAAE,EAAC,CAAC,EAAC,EAAE,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,GAAG,EAAC,EAAE,EAAC,EAAE,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,EAAE,EAAC,EAAE,EAAC,EAAE,EAAC,CAAC,EAAC,GAAG,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,EAAE,EAAC,CAAC,EAAC,EAAE,EAAC,EAAE,EAAC,EAAE,EAAC,CAAC,EAAC,EAAE,EAAC,EAAE,EAAC,CAAC,EAAC,CAAC,EAAC,EAAE,EAAC,EAAE,EAAC,CAAC,EAAC,CAAC,EAAC,GAAG,EAAC,EAAE,EAAC,GAAG,EAAC,CAAC,EAAC,EAAE,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,EAAE,EAAC,CAAC,EAAC,GAAG,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,EAAE,EAAC,CAAC,EAAC,EAAE,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,EAAE,EAAC,EAAE,EAAC,EAAE,EAAC,EAAE,EAAC,GAAG,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,EAAE,EAAC,CAAC,EAAC,EAAE,EAAC,EAAE,EAAC,CAAC,EAAC,EAAE,EAAC,GAAG,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,EAAE,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,GAAG,EAAC,CAAC,EAAC,EAAE,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,EAAE,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,EAAE,EAAC,CAAC,EAAC,IAAI,EAAC,CAAC,EAAC,CAAC,EAAC,EAAE,EAAC,KAAK,EAAC,CAAC,EAAC,EAAE,EAAC,CAAC,EAAC,EAAE,EAAC,CAAC,EAAC,EAAE,EAAC,CAAC,EAAC,EAAE,EAAC,CAAC,EAAC,IAAI,EAAC,CAAC,EAAC,CAAC,EAAC,EAAE,EAAC,CAAC,EAAC,CAAC,EAAC,EAAE,EAAC,CAAC,EAAC,EAAE,EAAC,CAAC,EAAC,KAAK,EAAC,CAAC,EAAC,IAAI,EAAC,EAAE,EAAC,CAAC,EAAC,EAAE,EAAC,GAAG,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,EAAE,EAAC,CAAC,EAAC,GAAG,EAAC,CAAC,EAAC,IAAI,EAAC,EAAE,EAAC,GAAG,EAAC,EAAE,EAAC,CAAC,EAAC,EAAE,EAAC,CAAC,EAAC,CAAC,EAAC,EAAE,EAAC,CAAC,EAAC,EAAE,EAAC,CAAC,EAAC,CAAC,E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"}��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������lib/options.js��������������������������������������������������������������������������������������0000644�����������������00000002060�15120211212�0007324 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.defaultOptions = void 0;
exports.getOptions = getOptions;
const defaultOptions = {
  sourceType: "script",
  sourceFilename: undefined,
  startColumn: 0,
  startLine: 1,
  allowAwaitOutsideFunction: false,
  allowReturnOutsideFunction: false,
  allowNewTargetOutsideFunction: false,
  allowImportExportEverywhere: false,
  allowSuperOutsideMethod: false,
  allowUndeclaredExports: false,
  plugins: [],
  strictMode: null,
  ranges: false,
  tokens: false,
  createParenthesizedExpressions: false,
  errorRecovery: false,
  attachComment: true,
  annexB: true
};
exports.defaultOptions = defaultOptions;
function getOptions(opts) {
  if (opts && opts.annexB != null && opts.annexB !== false) {
    throw new Error("The `annexB` option can only be set to `false`.");
  }
  const options = {};
  for (const key of Object.keys(defaultOptions)) {
    options[key] = opts && opts[key] != null ? opts[key] : defaultOptions[key];
  }
  return options;
}

//# sourceMappingURL=options.js.map
��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������lib/options.js.map����������������������������������������������������������������������������������0000644�����������������00000012363�15120211212�0010107 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������{"version":3,"names":["defaultOptions","sourceType","sourceFilename","undefined","startColumn","startLine","allowAwaitOutsideFunction","allowReturnOutsideFunction","allowNewTargetOutsideFunction","allowImportExportEverywhere","allowSuperOutsideMethod","allowUndeclaredExports","plugins","strictMode","ranges","tokens","createParenthesizedExpressions","errorRecovery","attachComment","annexB","exports","getOptions","opts","Error","options","key","Object","keys"],"sources":["../src/options.ts"],"sourcesContent":["import type { PluginList } from \"./plugin-utils\";\n\n// A second optional argument can be given to further configure\n// the parser process. These options are recognized:\n\nexport type SourceType = \"script\" | \"module\" | \"unambiguous\";\n\nexport type Options = {\n  sourceType: SourceType;\n  sourceFilename?: string;\n  startColumn: number;\n  startLine: number;\n  allowAwaitOutsideFunction: boolean;\n  allowReturnOutsideFunction: boolean;\n  allowNewTargetOutsideFunction: boolean;\n  allowImportExportEverywhere: boolean;\n  allowSuperOutsideMethod: boolean;\n  allowUndeclaredExports: boolean;\n  plugins: PluginList;\n  strictMode: boolean | undefined | null;\n  ranges: boolean;\n  tokens: boolean;\n  createParenthesizedExpressions: boolean;\n  errorRecovery: boolean;\n  attachComment: boolean;\n  annexB: boolean;\n};\n\nexport const defaultOptions: Options = {\n  // Source type (\"script\" or \"module\") for different semantics\n  sourceType: \"script\",\n  // Source filename.\n  sourceFilename: undefined,\n  // Column (0-based) from which to start counting source. Useful for\n  // integration with other tools.\n  startColumn: 0,\n  // Line (1-based) from which to start counting source. Useful for\n  // integration with other tools.\n  startLine: 1,\n  // When enabled, await at the top level is not considered an\n  // error.\n  allowAwaitOutsideFunction: false,\n  // When enabled, a return at the top level is not considered an\n  // error.\n  allowReturnOutsideFunction: false,\n  // When enabled, new.target outside a function or class is not\n  // considered an error.\n  allowNewTargetOutsideFunction: false,\n  // When enabled, import/export statements are not constrained to\n  // appearing at the top of the program.\n  allowImportExportEverywhere: false,\n  // TODO\n  allowSuperOutsideMethod: false,\n  // When enabled, export statements can reference undeclared variables.\n  allowUndeclaredExports: false,\n  // An array of plugins to enable\n  plugins: [],\n  // TODO\n  strictMode: null,\n  // Nodes have their start and end characters offsets recorded in\n  // `start` and `end` properties (directly on the node, rather than\n  // the `loc` object, which holds line/column data. To also add a\n  // [semi-standardized][range] `range` property holding a `[start,\n  // end]` array with the same numbers, set the `ranges` option to\n  // `true`.\n  //\n  // [range]: https://bugzilla.mozilla.org/show_bug.cgi?id=745678\n  ranges: false,\n  // Adds all parsed tokens to a `tokens` property on the `File` node\n  tokens: false,\n  // Whether to create ParenthesizedExpression AST nodes (if false\n  // the parser sets extra.parenthesized on the expression nodes instead).\n  createParenthesizedExpressions: false,\n  // When enabled, errors are attached to the AST instead of being directly thrown.\n  // Some errors will still throw, because @babel/parser can't always recover.\n  errorRecovery: false,\n  // When enabled, comments will be attached to adjacent AST nodes as one of\n  // `leadingComments`, `trailingComments` and `innerComments`. The comment attachment\n  // is vital to preserve comments after transform. If you don't print AST back,\n  // consider set this option to `false` for performance\n  attachComment: true,\n  // When enabled, the parser will support Annex B syntax.\n  // https://tc39.es/ecma262/#sec-additional-ecmascript-features-for-web-browsers\n  annexB: true,\n};\n\n// Interpret and default an options object\n\nexport function getOptions(opts?: Options | null): Options {\n  if (opts && opts.annexB != null && opts.annexB !== false) {\n    throw new Error(\"The `annexB` option can only be set to `false`.\");\n  }\n\n  const options: any = {};\n  for (const key of Object.keys(defaultOptions)) {\n    // @ts-expect-error key may not exist in opts\n    options[key] = opts && opts[key] != null ? opts[key] : defaultOptions[key];\n  }\n  return options;\n}\n"],"mappings":";;;;;;;AA4BO,MAAMA,cAAuB,GAAG;EAErCC,UAAU,EAAE,QAAQ;EAEpBC,cAAc,EAAEC,SAAS;EAGzBC,WAAW,EAAE,CAAC;EAGdC,SAAS,EAAE,CAAC;EAGZC,yBAAyB,EAAE,KAAK;EAGhCC,0BAA0B,EAAE,KAAK;EAGjCC,6BAA6B,EAAE,KAAK;EAGpCC,2BAA2B,EAAE,KAAK;EAElCC,uBAAuB,EAAE,KAAK;EAE9BC,sBAAsB,EAAE,KAAK;EAE7BC,OAAO,EAAE,EAAE;EAEXC,UAAU,EAAE,IAAI;EAShBC,MAAM,EAAE,KAAK;EAEbC,MAAM,EAAE,KAAK;EAGbC,8BAA8B,EAAE,KAAK;EAGrCC,aAAa,EAAE,KAAK;EAKpBC,aAAa,EAAE,IAAI;EAGnBC,MAAM,EAAE;AACV,CAAC;AAACC,OAAA,CAAApB,cAAA,GAAAA,cAAA;AAIK,SAASqB,UAAUA,CAACC,IAAqB,EAAW;EACzD,IAAIA,IAAI,IAAIA,IAAI,CAACH,MAAM,IAAI,IAAI,IAAIG,IAAI,CAACH,MAAM,KAAK,KAAK,EAAE;IACxD,MAAM,IAAII,KAAK,CAAC,iDAAiD,CAAC;EACpE;EAEA,MAAMC,OAAY,GAAG,CAAC,CAAC;EACvB,KAAK,MAAMC,GAAG,IAAIC,MAAM,CAACC,IAAI,CAAC3B,cAAc,CAAC,EAAE;IAE7CwB,OAAO,CAACC,GAAG,CAAC,GAAGH,IAAI,IAAIA,IAAI,CAACG,GAAG,CAAC,IAAI,IAAI,GAAGH,IAAI,CAACG,GAAG,CAAC,GAAGzB,cAAc,CAACyB,GAAG,CAAC;EAC5E;EACA,OAAOD,OAAO;AAChB"}�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������lib/parse-error.js����������������������������������������������������������������������������������0000644�����������������00000007276�15120211212�0010110 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
var _exportNames = {
  ParseErrorEnum: true,
  Errors: true
};
exports.Errors = void 0;
exports.ParseErrorEnum = ParseErrorEnum;
var _location = require("./util/location");
var _credentials = require("./parse-error/credentials");
Object.keys(_credentials).forEach(function (key) {
  if (key === "default" || key === "__esModule") return;
  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
  if (key in exports && exports[key] === _credentials[key]) return;
  Object.defineProperty(exports, key, {
    enumerable: true,
    get: function () {
      return _credentials[key];
    }
  });
});
var _moduleErrors = require("./parse-error/module-errors");
var _standardErrors = require("./parse-error/standard-errors");
var _strictModeErrors = require("./parse-error/strict-mode-errors");
var _pipelineOperatorErrors = require("./parse-error/pipeline-operator-errors");
const _excluded = ["toMessage"],
  _excluded2 = ["message"];
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 toParseErrorConstructor(_ref) {
  let {
      toMessage
    } = _ref,
    properties = _objectWithoutPropertiesLoose(_ref, _excluded);
  return function constructor({
    loc,
    details
  }) {
    return (0, _credentials.instantiate)(SyntaxError, Object.assign({}, properties, {
      loc
    }), {
      clone(overrides = {}) {
        const loc = overrides.loc || {};
        return constructor({
          loc: new _location.Position("line" in loc ? loc.line : this.loc.line, "column" in loc ? loc.column : this.loc.column, "index" in loc ? loc.index : this.loc.index),
          details: Object.assign({}, this.details, overrides.details)
        });
      },
      details: {
        value: details,
        enumerable: false
      },
      message: {
        get() {
          return `${toMessage(this.details)} (${this.loc.line}:${this.loc.column})`;
        },
        set(value) {
          Object.defineProperty(this, "message", {
            value
          });
        }
      },
      pos: {
        reflect: "loc.index",
        enumerable: true
      },
      missingPlugin: "missingPlugin" in details && {
        reflect: "details.missingPlugin",
        enumerable: true
      }
    });
  };
}
function ParseErrorEnum(argument, syntaxPlugin) {
  if (Array.isArray(argument)) {
    return parseErrorTemplates => ParseErrorEnum(parseErrorTemplates, argument[0]);
  }
  const ParseErrorConstructors = {};
  for (const reasonCode of Object.keys(argument)) {
    const template = argument[reasonCode];
    const _ref2 = typeof template === "string" ? {
        message: () => template
      } : typeof template === "function" ? {
        message: template
      } : template,
      {
        message
      } = _ref2,
      rest = _objectWithoutPropertiesLoose(_ref2, _excluded2);
    const toMessage = typeof message === "string" ? () => message : message;
    ParseErrorConstructors[reasonCode] = toParseErrorConstructor(Object.assign({
      code: _credentials.ParseErrorCode.SyntaxError,
      reasonCode,
      toMessage
    }, syntaxPlugin ? {
      syntaxPlugin
    } : {}, rest));
  }
  return ParseErrorConstructors;
}
const Errors = Object.assign({}, ParseErrorEnum(_moduleErrors.default), ParseErrorEnum(_standardErrors.default), ParseErrorEnum(_strictModeErrors.default), ParseErrorEnum`pipelineOperator`(_pipelineOperatorErrors.default));
exports.Errors = Errors;

//# sourceMappingURL=parse-error.js.map
����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������lib/parse-error.js.map������������������������������������������������������������������������������0000644�����������������00000027345�15120211212�0010663 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������{"version":3,"names":["_location","require","_credentials","Object","keys","forEach","key","prototype","hasOwnProperty","call","_exportNames","exports","defineProperty","enumerable","get","_moduleErrors","_standardErrors","_strictModeErrors","_pipelineOperatorErrors","_excluded","_excluded2","_objectWithoutPropertiesLoose","source","excluded","target","sourceKeys","i","length","indexOf","toParseErrorConstructor","_ref","toMessage","properties","constructor","loc","details","instantiate","SyntaxError","assign","clone","overrides","Position","line","column","index","value","message","set","pos","reflect","missingPlugin","ParseErrorEnum","argument","syntaxPlugin","Array","isArray","parseErrorTemplates","ParseErrorConstructors","reasonCode","template","_ref2","rest","code","ParseErrorCode","Errors","ModuleErrors","StandardErrors","StrictModeErrors","PipelineOperatorErrors"],"sources":["../src/parse-error.ts"],"sourcesContent":["import { Position } from \"./util/location\";\nimport {\n  instantiate,\n  ParseErrorCode,\n  type ParseErrorCredentials,\n  type ToMessage,\n  type SyntaxPlugin,\n} from \"./parse-error/credentials\";\nimport type { Undone } from \"./parser/node\";\nimport type { Node } from \"./types\";\n\n// Babel uses \"normal\" SyntaxErrors for it's errors, but adds some extra\n// functionality. This functionality is defined in the\n// `ParseErrorSpecification` interface below. We may choose to change to someday\n// give our errors their own full-blown class, but until then this allow us to\n// keep all the desirable properties of SyntaxErrors (like their name in stack\n// traces, etc.), and also allows us to punt on any publicly facing\n// class-hierarchy decisions until Babel 8.\ninterface ParseErrorSpecification<ErrorDetails> {\n  // Look, these *could* be readonly, but then Flow complains when we initially\n  // set them. We could do a whole dance and make a special interface that's not\n  // readonly for when we create the error, then cast it to the readonly\n  // interface for public use, but the previous implementation didn't have them\n  // as readonly, so let's just not worry about it for now.\n  code: ParseErrorCode;\n  reasonCode: string;\n  syntaxPlugin?: SyntaxPlugin;\n  missingPlugin?: string | string[];\n  loc: Position;\n  details: ErrorDetails;\n\n  // We should consider removing this as it now just contains the same\n  // information as `loc.index`.\n  // pos: number;\n}\n\nexport type ParseError<ErrorDetails> = SyntaxError &\n  ParseErrorSpecification<ErrorDetails>;\n\n// By `ParseErrorConstructor`, we mean something like the new-less style\n// `ErrorConstructor`[1], since `ParseError`'s are not themselves actually\n// separate classes from `SyntaxError`'s.\n//\n// 1. https://github.com/microsoft/TypeScript/blob/v4.5.5/lib/lib.es5.d.ts#L1027\nexport type ParseErrorConstructor<ErrorDetails> = (a: {\n  loc: Position;\n  details: ErrorDetails;\n}) => ParseError<ErrorDetails>;\n\nfunction toParseErrorConstructor<ErrorDetails extends object>({\n  toMessage,\n  ...properties\n}: ParseErrorCredentials<ErrorDetails>): ParseErrorConstructor<ErrorDetails> {\n  type ConstructorArgument = {\n    loc: Position;\n    details: ErrorDetails;\n  };\n\n  return function constructor({ loc, details }: ConstructorArgument) {\n    return instantiate(\n      SyntaxError,\n      { ...properties, loc },\n      {\n        clone(\n          overrides: {\n            loc?: Position;\n            details?: ErrorDetails;\n          } = {},\n        ) {\n          const loc = (overrides.loc || {}) as Partial<Position>;\n          return constructor({\n            loc: new Position(\n              \"line\" in loc ? loc.line : this.loc.line,\n              \"column\" in loc ? loc.column : this.loc.column,\n              \"index\" in loc ? loc.index : this.loc.index,\n            ),\n            details: { ...this.details, ...overrides.details },\n          });\n        },\n        details: { value: details, enumerable: false },\n        message: {\n          get(this: ConstructorArgument): string {\n            return `${toMessage(this.details)} (${this.loc.line}:${\n              this.loc.column\n            })`;\n          },\n          set(value: string) {\n            Object.defineProperty(this, \"message\", { value });\n          },\n        },\n        pos: { reflect: \"loc.index\", enumerable: true },\n        missingPlugin: \"missingPlugin\" in details && {\n          reflect: \"details.missingPlugin\",\n          enumerable: true,\n        },\n      },\n    ) as ParseError<ErrorDetails>;\n  };\n}\n\ntype ParseErrorTemplate =\n  | string\n  | ToMessage<any>\n  | { message: string | ToMessage<any> };\n\ntype ParseErrorTemplates = { [reasonCode: string]: ParseErrorTemplate };\n\n// This is the templated form of `ParseErrorEnum`.\n//\n// Note: We could factor out the return type calculation into something like\n// `ParseErrorConstructor<T extends ParseErrorTemplates>`, and then we could\n// reuse it in the non-templated form of `ParseErrorEnum`, but TypeScript\n// doesn't seem to drill down that far when showing you the computed type of\n// an object in an editor, so we'll leave it inlined for now.\nexport function ParseErrorEnum(a: TemplateStringsArray): <\n  T extends ParseErrorTemplates,\n>(\n  parseErrorTemplates: T,\n) => {\n  [K in keyof T]: ParseErrorConstructor<\n    T[K] extends { message: string | ToMessage<any> }\n      ? T[K][\"message\"] extends ToMessage<any>\n        ? Parameters<T[K][\"message\"]>[0]\n        : {}\n      : T[K] extends ToMessage<any>\n      ? Parameters<T[K]>[0]\n      : {}\n  >;\n};\n\nexport function ParseErrorEnum<T extends ParseErrorTemplates>(\n  parseErrorTemplates: T,\n  syntaxPlugin?: SyntaxPlugin,\n): {\n  [K in keyof T]: ParseErrorConstructor<\n    T[K] extends { message: string | ToMessage<any> }\n      ? T[K][\"message\"] extends ToMessage<any>\n        ? Parameters<T[K][\"message\"]>[0]\n        : {}\n      : T[K] extends ToMessage<any>\n      ? Parameters<T[K]>[0]\n      : {}\n  >;\n};\n\n// You call `ParseErrorEnum` with a mapping from `ReasonCode`'s to either:\n//\n// 1. a static error message,\n// 2. `toMessage` functions that define additional necessary `details` needed by\n//    the `ParseError`, or\n// 3. Objects that contain a `message` of one of the above and overridden `code`\n//    and/or `reasonCode`:\n//\n// ParseErrorEnum `optionalSyntaxPlugin` ({\n//   ErrorWithStaticMessage: \"message\",\n//   ErrorWithDynamicMessage: ({ type } : { type: string }) => `${type}`),\n//   ErrorWithOverriddenCodeAndOrReasonCode: {\n//     message: ({ type }: { type: string }) => `${type}`),\n//     code: ParseErrorCode.SourceTypeModuleError,\n//     ...(BABEL_8_BREAKING ? { } : { reasonCode: \"CustomErrorReasonCode\" })\n//   }\n// });\n//\nexport function ParseErrorEnum(\n  argument: TemplateStringsArray | ParseErrorTemplates,\n  syntaxPlugin?: SyntaxPlugin,\n) {\n  // If the first parameter is an array, that means we were called with a tagged\n  // template literal. Extract the syntaxPlugin from this, and call again in\n  // the \"normalized\" form.\n  if (Array.isArray(argument)) {\n    return (parseErrorTemplates: ParseErrorTemplates) =>\n      ParseErrorEnum(parseErrorTemplates, argument[0]);\n  }\n\n  const ParseErrorConstructors = {} as Record<\n    string,\n    ParseErrorConstructor<unknown>\n  >;\n\n  for (const reasonCode of Object.keys(argument)) {\n    const template = (argument as ParseErrorTemplates)[reasonCode];\n    const { message, ...rest } =\n      typeof template === \"string\"\n        ? { message: () => template }\n        : typeof template === \"function\"\n        ? { message: template }\n        : template;\n    const toMessage = typeof message === \"string\" ? () => message : message;\n\n    ParseErrorConstructors[reasonCode] = toParseErrorConstructor({\n      code: ParseErrorCode.SyntaxError,\n      reasonCode,\n      toMessage,\n      ...(syntaxPlugin ? { syntaxPlugin } : {}),\n      ...rest,\n    });\n  }\n\n  return ParseErrorConstructors;\n}\n\nexport type RaiseProperties<ErrorDetails> = {\n  at: Position | Undone<Node>;\n} & ErrorDetails;\n\nimport ModuleErrors from \"./parse-error/module-errors\";\nimport StandardErrors from \"./parse-error/standard-errors\";\nimport StrictModeErrors from \"./parse-error/strict-mode-errors\";\nimport PipelineOperatorErrors from \"./parse-error/pipeline-operator-errors\";\n\nexport const Errors = {\n  ...ParseErrorEnum(ModuleErrors),\n  ...ParseErrorEnum(StandardErrors),\n  ...ParseErrorEnum(StrictModeErrors),\n  ...ParseErrorEnum`pipelineOperator`(PipelineOperatorErrors),\n};\n\nexport type { LValAncestor } from \"./parse-error/standard-errors\";\n\nexport * from \"./parse-error/credentials\";\n"],"mappings":"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"}�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������lib/parse-error/credentials.js����������������������������������������������������������������������0000644�����������������00000002270�15120211212�0012372 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.instantiate = exports.ParseErrorCode = void 0;
var ParseErrorCode = {
  SyntaxError: "BABEL_PARSER_SYNTAX_ERROR",
  SourceTypeModuleError: "BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED"
};
exports.ParseErrorCode = ParseErrorCode;
const reflect = (keys, last = keys.length - 1) => ({
  get() {
    return keys.reduce((object, key) => object[key], this);
  },
  set(value) {
    keys.reduce((item, key, i) => i === last ? item[key] = value : item[key], this);
  }
});
const instantiate = (constructor, properties, descriptors) => Object.keys(descriptors).map(key => [key, descriptors[key]]).filter(([, descriptor]) => !!descriptor).map(([key, descriptor]) => [key, typeof descriptor === "function" ? {
  value: descriptor,
  enumerable: false
} : typeof descriptor.reflect === "string" ? Object.assign({}, descriptor, reflect(descriptor.reflect.split("."))) : descriptor]).reduce((instance, [key, descriptor]) => Object.defineProperty(instance, key, Object.assign({
  configurable: true
}, descriptor)), Object.assign(new constructor(), properties));
exports.instantiate = instantiate;

//# sourceMappingURL=credentials.js.map
����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������lib/parse-error/credentials.js.map������������������������������������������������������������������0000644�����������������00000006716�15120211212�0013157 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������{"version":3,"names":["ParseErrorCode","SyntaxError","SourceTypeModuleError","exports","reflect","keys","last","length","get","reduce","object","key","set","value","item","i","instantiate","constructor","properties","descriptors","Object","map","filter","descriptor","enumerable","assign","split","instance","defineProperty","configurable"],"sources":["../../src/parse-error/credentials.ts"],"sourcesContent":["export const enum ParseErrorCode {\n  SyntaxError = \"BABEL_PARSER_SYNTAX_ERROR\",\n  SourceTypeModuleError = \"BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED\",\n}\n\nexport type SyntaxPlugin =\n  | \"flow\"\n  | \"typescript\"\n  | \"jsx\"\n  | \"pipelineOperator\"\n  | \"placeholders\";\n\nexport type ToMessage<ErrorDetails> = (self: ErrorDetails) => string;\n\nexport type ParseErrorCredentials<ErrorDetails> = {\n  code: ParseErrorCode;\n  reasonCode: string;\n  syntaxPlugin?: SyntaxPlugin;\n  toMessage: ToMessage<ErrorDetails>;\n};\n\nconst reflect = (keys: string[], last = keys.length - 1) => ({\n  get(this: unknown): unknown {\n    return keys.reduce(\n      (object, key) =>\n        // @ts-expect-error key should index object\n        object[key],\n      this,\n    );\n  },\n  set(this: unknown, value: unknown) {\n    keys.reduce(\n      // @ts-expect-error key should index item\n      (item, key, i) => (i === last ? (item[key] = value) : item[key]),\n      this,\n    );\n  },\n});\n\nconst instantiate = <T>(\n  constructor: new () => T,\n  properties: any,\n  descriptors: any,\n) =>\n  Object.keys(descriptors)\n    .map(key => [key, descriptors[key]])\n    .filter(([, descriptor]) => !!descriptor)\n    .map(([key, descriptor]) => [\n      key,\n      typeof descriptor === \"function\"\n        ? { value: descriptor, enumerable: false }\n        : typeof descriptor.reflect === \"string\"\n        ? { ...descriptor, ...reflect(descriptor.reflect.split(\".\")) }\n        : descriptor,\n    ])\n    .reduce(\n      (instance, [key, descriptor]) =>\n        Object.defineProperty(instance, key, {\n          configurable: true,\n          ...descriptor,\n        }),\n      Object.assign(new constructor(), properties),\n    );\n\nexport { instantiate };\n"],"mappings":";;;;;;IAAkBA,cAAc;EAAAC,WAAA;EAAAC,qBAAA;AAAA;AAAAC,OAAA,CAAAH,cAAA,GAAAA,cAAA;AAqBhC,MAAMI,OAAO,GAAGA,CAACC,IAAc,EAAEC,IAAI,GAAGD,IAAI,CAACE,MAAM,GAAG,CAAC,MAAM;EAC3DC,GAAGA,CAAA,EAAyB;IAC1B,OAAOH,IAAI,CAACI,MAAM,CAChB,CAACC,MAAM,EAAEC,GAAG,KAEVD,MAAM,CAACC,GAAG,CAAC,EACb,IACF,CAAC;EACH,CAAC;EACDC,GAAGA,CAAgBC,KAAc,EAAE;IACjCR,IAAI,CAACI,MAAM,CAET,CAACK,IAAI,EAAEH,GAAG,EAAEI,CAAC,KAAMA,CAAC,KAAKT,IAAI,GAAIQ,IAAI,CAACH,GAAG,CAAC,GAAGE,KAAK,GAAIC,IAAI,CAACH,GAAG,CAAE,EAChE,IACF,CAAC;EACH;AACF,CAAC,CAAC;AAEF,MAAMK,WAAW,GAAGA,CAClBC,WAAwB,EACxBC,UAAe,EACfC,WAAgB,KAEhBC,MAAM,CAACf,IAAI,CAACc,WAAW,CAAC,CACrBE,GAAG,CAACV,GAAG,IAAI,CAACA,GAAG,EAAEQ,WAAW,CAACR,GAAG,CAAC,CAAC,CAAC,CACnCW,MAAM,CAAC,CAAC,GAAGC,UAAU,CAAC,KAAK,CAAC,CAACA,UAAU,CAAC,CACxCF,GAAG,CAAC,CAAC,CAACV,GAAG,EAAEY,UAAU,CAAC,KAAK,CAC1BZ,GAAG,EACH,OAAOY,UAAU,KAAK,UAAU,GAC5B;EAAEV,KAAK,EAAEU,UAAU;EAAEC,UAAU,EAAE;AAAM,CAAC,GACxC,OAAOD,UAAU,CAACnB,OAAO,KAAK,QAAQ,GAAAgB,MAAA,CAAAK,MAAA,KACjCF,UAAU,EAAKnB,OAAO,CAACmB,UAAU,CAACnB,OAAO,CAACsB,KAAK,CAAC,GAAG,CAAC,CAAC,IAC1DH,UAAU,CACf,CAAC,CACDd,MAAM,CACL,CAACkB,QAAQ,EAAE,CAAChB,GAAG,EAAEY,UAAU,CAAC,KAC1BH,MAAM,CAACQ,cAAc,CAACD,QAAQ,EAAEhB,GAAG,EAAAS,MAAA,CAAAK,MAAA;EACjCI,YAAY,EAAE;AAAI,GACfN,UAAU,CACd,CAAC,EACJH,MAAM,CAACK,MAAM,CAAC,IAAIR,WAAW,CAAC,CAAC,EAAEC,UAAU,CAC7C,CAAC;AAACf,OAAA,CAAAa,WAAA,GAAAA,WAAA"}��������������������������������������������������lib/parse-error/module-errors.js��������������������������������������������������������������������0000644�����������������00000001101�15120211212�0012664 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;
var _parseError = require("../parse-error");
var _default = {
  ImportMetaOutsideModule: {
    message: `import.meta may appear only with 'sourceType: "module"'`,
    code: _parseError.ParseErrorCode.SourceTypeModuleError
  },
  ImportOutsideModule: {
    message: `'import' and 'export' may appear only with 'sourceType: "module"'`,
    code: _parseError.ParseErrorCode.SourceTypeModuleError
  }
};
exports.default = _default;

//# sourceMappingURL=module-errors.js.map
���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������lib/parse-error/module-errors.js.map����������������������������������������������������������������0000644�����������������00000001646�15120211212�0013456 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������{"version":3,"names":["_parseError","require","_default","ImportMetaOutsideModule","message","code","ParseErrorCode","SourceTypeModuleError","ImportOutsideModule","exports","default"],"sources":["../../src/parse-error/module-errors.ts"],"sourcesContent":["import { ParseErrorCode } from \"../parse-error\";\n\nexport default {\n  ImportMetaOutsideModule: {\n    message: `import.meta may appear only with 'sourceType: \"module\"'`,\n    code: ParseErrorCode.SourceTypeModuleError,\n  },\n  ImportOutsideModule: {\n    message: `'import' and 'export' may appear only with 'sourceType: \"module\"'`,\n    code: ParseErrorCode.SourceTypeModuleError,\n  },\n};\n"],"mappings":";;;;;;AAAA,IAAAA,WAAA,GAAAC,OAAA;AAAgD,IAAAC,QAAA,GAEjC;EACbC,uBAAuB,EAAE;IACvBC,OAAO,EAAG,yDAAwD;IAClEC,IAAI,EAAEC,0BAAc,CAACC;EACvB,CAAC;EACDC,mBAAmB,EAAE;IACnBJ,OAAO,EAAG,mEAAkE;IAC5EC,IAAI,EAAEC,0BAAc,CAACC;EACvB;AACF,CAAC;AAAAE,OAAA,CAAAC,OAAA,GAAAR,QAAA"}������������������������������������������������������������������������������������������lib/parse-error/pipeline-operator-errors.js���������������������������������������������������������0000644�����������������00000004152�15120211212�0015046 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = exports.UnparenthesizedPipeBodyDescriptions = void 0;
var _toNodeDescription = require("./to-node-description");
const UnparenthesizedPipeBodyDescriptions = new Set(["ArrowFunctionExpression", "AssignmentExpression", "ConditionalExpression", "YieldExpression"]);
exports.UnparenthesizedPipeBodyDescriptions = UnparenthesizedPipeBodyDescriptions;
var _default = {
  PipeBodyIsTighter: "Unexpected yield after pipeline body; any yield 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: ({
    token
  }) => `Invalid topic token ${token}. In order to use ${token} as a topic reference, the pipelineOperator plugin must be configured with { "proposal": "hack", "topicToken": "${token}" }.`,
  PipeTopicUnused: "Hack-style pipe body does not contain a topic reference; Hack-style pipes must use topic at least once.",
  PipeUnparenthesizedBody: ({
    type
  }) => `Hack-style pipe body cannot be an unparenthesized ${(0, _toNodeDescription.default)({
    type
  })}; 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.'
};
exports.default = _default;

//# sourceMappingURL=pipeline-operator-errors.js.map
����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������lib/parse-error/pipeline-operator-errors.js.map�����������������������������������������������������0000644�����������������00000007331�15120211212�0015624 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������{"version":3,"names":["_toNodeDescription","require","UnparenthesizedPipeBodyDescriptions","Set","exports","_default","PipeBodyIsTighter","PipeTopicRequiresHackPipes","PipeTopicUnbound","PipeTopicUnconfiguredToken","token","PipeTopicUnused","PipeUnparenthesizedBody","type","toNodeDescription","PipelineBodyNoArrow","PipelineBodySequenceExpression","PipelineHeadSequenceExpression","PipelineTopicUnused","PrimaryTopicNotAllowed","PrimaryTopicRequiresSmartPipeline","default"],"sources":["../../src/parse-error/pipeline-operator-errors.ts"],"sourcesContent":["import toNodeDescription from \"./to-node-description\";\n\nexport const UnparenthesizedPipeBodyDescriptions = new Set([\n  \"ArrowFunctionExpression\",\n  \"AssignmentExpression\",\n  \"ConditionalExpression\",\n  \"YieldExpression\",\n] as const);\n\ntype GetSetMemberType<T extends Set<any>> = T extends Set<infer M>\n  ? M\n  : unknown;\n\ntype UnparenthesizedPipeBodyTypes = GetSetMemberType<\n  typeof UnparenthesizedPipeBodyDescriptions\n>;\n\nexport default {\n  // This error is only used by the smart-mix proposal\n  PipeBodyIsTighter:\n    \"Unexpected yield after pipeline body; any yield 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: ({ token }: { token: string }) =>\n    `Invalid topic token ${token}. In order to use ${token} as a topic reference, the pipelineOperator plugin must be configured with { \"proposal\": \"hack\", \"topicToken\": \"${token}\" }.`,\n  PipeTopicUnused:\n    \"Hack-style pipe body does not contain a topic reference; Hack-style pipes must use topic at least once.\",\n  PipeUnparenthesizedBody: ({ type }: { type: UnparenthesizedPipeBodyTypes }) =>\n    `Hack-style pipe body cannot be an unparenthesized ${toNodeDescription({\n      type,\n    })}; 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"],"mappings":";;;;;;AAAA,IAAAA,kBAAA,GAAAC,OAAA;AAEO,MAAMC,mCAAmC,GAAG,IAAIC,GAAG,CAAC,CACzD,yBAAyB,EACzB,sBAAsB,EACtB,uBAAuB,EACvB,iBAAiB,CACT,CAAC;AAACC,OAAA,CAAAF,mCAAA,GAAAA,mCAAA;AAAA,IAAAG,QAAA,GAUG;EAEbC,iBAAiB,EACf,uJAAuJ;EACzJC,0BAA0B,EACxB,iHAAiH;EACnHC,gBAAgB,EACd,4DAA4D;EAC9DC,0BAA0B,EAAEA,CAAC;IAAEC;EAAyB,CAAC,KACtD,uBAAsBA,KAAM,qBAAoBA,KAAM,mHAAkHA,KAAM,MAAK;EACtLC,eAAe,EACb,yGAAyG;EAC3GC,uBAAuB,EAAEA,CAAC;IAAEC;EAA6C,CAAC,KACvE,qDAAoD,IAAAC,0BAAiB,EAAC;IACrED;EACF,CAAC,CAAE,kCAAiC;EAMtCE,mBAAmB,EACjB,mGAAmG;EACrGC,8BAA8B,EAC5B,iEAAiE;EACnEC,8BAA8B,EAC5B,oEAAoE;EACtEC,mBAAmB,EACjB,8DAA8D;EAChEC,sBAAsB,EACpB,sEAAsE;EACxEC,iCAAiC,EAC/B;AACJ,CAAC;AAAAhB,OAAA,CAAAiB,OAAA,GAAAhB,QAAA"}�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������lib/parse-error/standard-errors.js������������������������������������������������������������������0000644�����������������00000034726�15120211212�0013222 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;
var _toNodeDescription = require("./to-node-description");
var _default = {
  AccessorIsGenerator: ({
    kind
  }) => `A ${kind}ter 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.",
  AwaitUsingNotInAsyncContext: "'await using' is only allowed within async functions and at the top levels of modules.",
  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' accessor must not have any formal parameters.",
  BadSetterArity: "A 'set' accessor must have exactly one formal parameter.",
  BadSetterRestParameter: "A 'set' accessor 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: ({
    kind
  }) => `Missing initializer in ${kind} declaration.`,
  DecoratorArgumentsOutsideParentheses: "Decorator arguments must be moved inside parentheses: use '@(decorator(args))' instead of '@(decorator)(args)'.",
  DecoratorBeforeExport: "Decorators must be placed *before* the 'export' keyword. Remove the 'decoratorsBeforeExport: true' option to use the 'export @decorator class {}' syntax.",
  DecoratorsBeforeAfterExport: "Decorators can be placed *either* before or after the 'export' keyword, but not in both locations at the same time.",
  DecoratorConstructor: "Decorators can't be used with a constructor. Did you mean '@dec class { ... }'?",
  DecoratorExportClass: "Decorators must be placed *after* the 'export' keyword. Remove the 'decoratorsBeforeExport: false' option to use the '@decorator export class {}' syntax.",
  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: ({
    exportName
  }) => `\`${exportName}\` 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: ({
    localName,
    exportName
  }) => `A string literal cannot be used as an exported binding without \`from\`.\n- Did you mean \`export { '${localName}' as '${exportName}' } from 'some-module'\`?`,
  ExportDefaultFromAsIdentifier: "'from' is not allowed as an identifier after 'export default'.",
  ForInOfLoopInitializer: ({
    type
  }) => `'${type === "ForInStatement" ? "for-in" : "for-of"}' loop variable declaration may not have an initializer.`,
  ForInUsing: "For-in loop may not start with 'using' declaration.",
  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: ({
    type
  }) => `Unsyntactic ${type === "BreakStatement" ? "break" : "continue"}.`,
  IllegalLanguageModeDirective: "Illegal 'use strict' directive in function with non-simple parameter list.",
  IllegalReturn: "'return' outside of function.",
  ImportAttributesUseAssert: "The `assert` keyword in import attributes is deprecated and it has been replaced by the `with` keyword. You can enable the `deprecatedAssertSyntax: true` option in the import attributes plugin to suppress this error.",
  ImportBindingIsString: ({
    importName
  }) => `A string literal cannot be used as an imported binding.\n- Did you mean \`import { "${importName}" as foo }\`?`,
  ImportCallArgumentTrailingComma: "Trailing comma is disallowed inside import(...) arguments.",
  ImportCallArity: ({
    maxArgumentCount
  }) => `\`import()\` requires exactly ${maxArgumentCount === 1 ? "one argument" : "one or two arguments"}.`,
  ImportCallNotNewExpression: "Cannot use new with import(...).",
  ImportCallSpreadArgument: "`...` is not allowed in `import()`.",
  ImportJSONBindingNotDefault: "A JSON module can only be imported with `default`.",
  ImportReflectionHasAssertion: "`import module x` cannot have assertions.",
  ImportReflectionNotBinding: 'Only `import module x from "./module"` is valid.',
  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: ({
    radix
  }) => `Expected number in radix ${radix}.`,
  InvalidEscapeSequence: "Bad character escape sequence.",
  InvalidEscapeSequenceTemplate: "Invalid escape sequence in template.",
  InvalidEscapedReservedWord: ({
    reservedWord
  }) => `Escape sequence in keyword ${reservedWord}.`,
  InvalidIdentifier: ({
    identifierName
  }) => `Invalid identifier ${identifierName}.`,
  InvalidLhs: ({
    ancestor
  }) => `Invalid left-hand side in ${(0, _toNodeDescription.default)(ancestor)}.`,
  InvalidLhsBinding: ({
    ancestor
  }) => `Binding invalid left-hand side in ${(0, _toNodeDescription.default)(ancestor)}.`,
  InvalidNumber: "Invalid number.",
  InvalidOrMissingExponent: "Floating-point numbers require a valid exponent after the 'e'.",
  InvalidOrUnexpectedToken: ({
    unexpected
  }) => `Unexpected character '${unexpected}'.`,
  InvalidParenthesizedAssignment: "Invalid parenthesized assignment pattern.",
  InvalidPrivateFieldResolution: ({
    identifierName
  }) => `Private name #${identifierName} 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: ({
    labelName
  }) => `Label '${labelName}' 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.",
  MissingPlugin: ({
    missingPlugin
  }) => `This experimental syntax requires enabling the parser plugin: ${missingPlugin.map(name => JSON.stringify(name)).join(", ")}.`,
  MissingOneOfPlugins: ({
    missingPlugin
  }) => `This experimental syntax requires enabling one of the following parser plugin(s): ${missingPlugin.map(name => JSON.stringify(name)).join(", ")}.`,
  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: ({
    key
  }) => `Duplicate key "${key}" is not allowed in module attributes.`,
  ModuleExportNameHasLoneSurrogate: ({
    surrogateCharCode
  }) => `An export name cannot include a lone surrogate, found '\\u${surrogateCharCode.toString(16)}'.`,
  ModuleExportUndefined: ({
    localName
  }) => `Export '${localName}' 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.",
  PrivateInExpectedIn: ({
    identifierName
  }) => `Private names are only allowed in property accesses (\`obj.#${identifierName}\`) or in \`in\` expressions (\`#${identifierName} in obj\`).`,
  PrivateNameRedeclaration: ({
    identifierName
  }) => `Duplicate private name #${identifierName}.`,
  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 or inside a block.",
  SloppyFunctionAnnexB: "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.",
  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: ({
    keyword
  }) => `Unexpected keyword '${keyword}'.`,
  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: ({
    reservedWord
  }) => `Unexpected reserved word '${reservedWord}'.`,
  UnexpectedSuper: "'super' is only allowed in object methods and classes.",
  UnexpectedToken: ({
    expected,
    unexpected
  }) => `Unexpected token${unexpected ? ` '${unexpected}'.` : ""}${expected ? `, expected "${expected}"` : ""}`,
  UnexpectedTokenUnaryExponentiation: "Illegal expression. Wrap left hand side or entire exponentiation in parentheses.",
  UnexpectedUsingDeclaration: "Using declaration cannot appear in the top level when source type is `script`.",
  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: ({
    target,
    onlyValidPropertyName
  }) => `The only valid meta property for ${target} is ${target}.${onlyValidPropertyName}.`,
  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.",
  UsingDeclarationHasBindingPattern: "Using declaration cannot have destructuring patterns.",
  VarRedeclaration: ({
    identifierName
  }) => `Identifier '${identifierName}' has already been declared.`,
  YieldBindingIdentifier: "Can not use 'yield' as identifier inside a generator.",
  YieldInParameter: "Yield expression is not allowed in formal parameters.",
  ZeroDigitNumericSeparator: "Numeric separator can not be used after leading 0."
};
exports.default = _default;

//# sourceMappingURL=standard-errors.js.map
������������������������������������������lib/parse-error/standard-errors.js.map��������������������������������������������������������������0000644�����������������00000064650�15120211212�0013775 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������{"version":3,"names":["_toNodeDescription","require","_default","AccessorIsGenerator","kind","ArgumentsInClass","AsyncFunctionInSingleStatementContext","AwaitBindingIdentifier","AwaitBindingIdentifierInStaticBlock","AwaitExpressionFormalParameter","AwaitUsingNotInAsyncContext","AwaitNotInAsyncContext","AwaitNotInAsyncFunction","BadGetterArity","BadSetterArity","BadSetterRestParameter","ConstructorClassField","ConstructorClassPrivateField","ConstructorIsAccessor","ConstructorIsAsync","ConstructorIsGenerator","DeclarationMissingInitializer","DecoratorArgumentsOutsideParentheses","DecoratorBeforeExport","DecoratorsBeforeAfterExport","DecoratorConstructor","DecoratorExportClass","DecoratorSemicolon","DecoratorStaticBlock","DeletePrivateField","DestructureNamedImport","DuplicateConstructor","DuplicateDefaultExport","DuplicateExport","exportName","DuplicateProto","DuplicateRegExpFlags","ElementAfterRest","EscapedCharNotAnIdentifier","ExportBindingIsString","localName","ExportDefaultFromAsIdentifier","ForInOfLoopInitializer","type","ForInUsing","ForOfAsync","ForOfLet","GeneratorInSingleStatementContext","IllegalBreakContinue","IllegalLanguageModeDirective","IllegalReturn","ImportAttributesUseAssert","ImportBindingIsString","importName","ImportCallArgumentTrailingComma","ImportCallArity","maxArgumentCount","ImportCallNotNewExpression","ImportCallSpreadArgument","ImportJSONBindingNotDefault","ImportReflectionHasAssertion","ImportReflectionNotBinding","IncompatibleRegExpUVFlags","InvalidBigIntLiteral","InvalidCodePoint","InvalidCoverInitializedName","InvalidDecimal","InvalidDigit","radix","InvalidEscapeSequence","InvalidEscapeSequenceTemplate","InvalidEscapedReservedWord","reservedWord","InvalidIdentifier","identifierName","InvalidLhs","ancestor","toNodeDescription","InvalidLhsBinding","InvalidNumber","InvalidOrMissingExponent","InvalidOrUnexpectedToken","unexpected","InvalidParenthesizedAssignment","InvalidPrivateFieldResolution","InvalidPropertyBindingPattern","InvalidRecordProperty","InvalidRestAssignmentPattern","LabelRedeclaration","labelName","LetInLexicalBinding","LineTerminatorBeforeArrow","MalformedRegExpFlags","MissingClassName","MissingEqInAssignment","MissingSemicolon","MissingPlugin","missingPlugin","map","name","JSON","stringify","join","MissingOneOfPlugins","MissingUnicodeEscape","MixingCoalesceWithLogical","ModuleAttributeDifferentFromType","ModuleAttributeInvalidValue","ModuleAttributesWithDuplicateKeys","key","ModuleExportNameHasLoneSurrogate","surrogateCharCode","toString","ModuleExportUndefined","MultipleDefaultsInSwitch","NewlineAfterThrow","NoCatchOrFinally","NumberIdentifier","NumericSeparatorInEscapeSequence","ObsoleteAwaitStar","OptionalChainingNoNew","OptionalChainingNoTemplate","OverrideOnConstructor","ParamDupe","PatternHasAccessor","PatternHasMethod","PrivateInExpectedIn","PrivateNameRedeclaration","RecordExpressionBarIncorrectEndSyntaxType","RecordExpressionBarIncorrectStartSyntaxType","RecordExpressionHashIncorrectStartSyntaxType","RecordNoProto","RestTrailingComma","SloppyFunction","SloppyFunctionAnnexB","StaticPrototype","SuperNotAllowed","SuperPrivateField","TrailingDecorator","TupleExpressionBarIncorrectEndSyntaxType","TupleExpressionBarIncorrectStartSyntaxType","TupleExpressionHashIncorrectStartSyntaxType","UnexpectedArgumentPlaceholder","UnexpectedAwaitAfterPipelineBody","UnexpectedDigitAfterHash","UnexpectedImportExport","UnexpectedKeyword","keyword","UnexpectedLeadingDecorator","UnexpectedLexicalDeclaration","UnexpectedNewTarget","UnexpectedNumericSeparator","UnexpectedPrivateField","UnexpectedReservedWord","UnexpectedSuper","UnexpectedToken","expected","UnexpectedTokenUnaryExponentiation","UnexpectedUsingDeclaration","UnsupportedBind","UnsupportedDecoratorExport","UnsupportedDefaultExport","UnsupportedImport","UnsupportedMetaProperty","target","onlyValidPropertyName","UnsupportedParameterDecorator","UnsupportedPropertyDecorator","UnsupportedSuper","UnterminatedComment","UnterminatedRegExp","UnterminatedString","UnterminatedTemplate","UsingDeclarationHasBindingPattern","VarRedeclaration","YieldBindingIdentifier","YieldInParameter","ZeroDigitNumericSeparator","exports","default"],"sources":["../../src/parse-error/standard-errors.ts"],"sourcesContent":["import toNodeDescription from \"./to-node-description\";\n\nexport type LValAncestor =\n  | { type: \"UpdateExpression\"; prefix: boolean }\n  | {\n      type:\n        | \"ArrayPattern\"\n        | \"AssignmentExpression\"\n        | \"CatchClause\"\n        | \"ForOfStatement\"\n        | \"FormalParameters\"\n        | \"ForInStatement\"\n        | \"ForStatement\"\n        | \"ImportSpecifier\"\n        | \"ImportNamespaceSpecifier\"\n        | \"ImportDefaultSpecifier\"\n        | \"ParenthesizedExpression\"\n        | \"ObjectPattern\"\n        | \"RestElement\"\n        | \"VariableDeclarator\";\n    };\n\nexport default {\n  AccessorIsGenerator: ({ kind }: { kind: \"get\" | \"set\" }) =>\n    `A ${kind}ter 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  AwaitUsingNotInAsyncContext:\n    \"'await using' is only allowed within async functions and at the top levels of modules.\",\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' accessor must not have any formal parameters.\",\n  BadSetterArity: \"A 'set' accessor must have exactly one formal parameter.\",\n  BadSetterRestParameter:\n    \"A 'set' accessor 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: ({\n    kind,\n  }: {\n    kind: \"const\" | \"destructuring\";\n  }) => `Missing initializer in ${kind} declaration.`,\n  DecoratorArgumentsOutsideParentheses:\n    \"Decorator arguments must be moved inside parentheses: use '@(decorator(args))' instead of '@(decorator)(args)'.\",\n  DecoratorBeforeExport:\n    \"Decorators must be placed *before* the 'export' keyword. Remove the 'decoratorsBeforeExport: true' option to use the 'export @decorator class {}' syntax.\",\n  DecoratorsBeforeAfterExport:\n    \"Decorators can be placed *either* before or after the 'export' keyword, but not in both locations at the same time.\",\n  DecoratorConstructor:\n    \"Decorators can't be used with a constructor. Did you mean '@dec class { ... }'?\",\n  DecoratorExportClass:\n    \"Decorators must be placed *after* the 'export' keyword. Remove the 'decoratorsBeforeExport: false' option to use the '@decorator export class {}' syntax.\",\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: ({ exportName }: { exportName: string }) =>\n    `\\`${exportName}\\` 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    localName,\n    exportName,\n  }: {\n    localName: string;\n    exportName: string;\n  }) =>\n    `A string literal cannot be used as an exported binding without \\`from\\`.\\n- Did you mean \\`export { '${localName}' as '${exportName}' } from 'some-module'\\`?`,\n  ExportDefaultFromAsIdentifier:\n    \"'from' is not allowed as an identifier after 'export default'.\",\n\n  ForInOfLoopInitializer: ({\n    type,\n  }: {\n    type: \"ForInStatement\" | \"ForOfStatement\";\n  }) =>\n    `'${\n      type === \"ForInStatement\" ? \"for-in\" : \"for-of\"\n    }' loop variable declaration may not have an initializer.`,\n  ForInUsing: \"For-in loop may not start with 'using' declaration.\",\n\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\n  IllegalBreakContinue: ({\n    type,\n  }: {\n    type: \"BreakStatement\" | \"ContinueStatement\";\n  }) => `Unsyntactic ${type === \"BreakStatement\" ? \"break\" : \"continue\"}.`,\n\n  IllegalLanguageModeDirective:\n    \"Illegal 'use strict' directive in function with non-simple parameter list.\",\n  IllegalReturn: \"'return' outside of function.\",\n  ImportAttributesUseAssert:\n    \"The `assert` keyword in import attributes is deprecated and it has been replaced by the `with` keyword. You can enable the `deprecatedAssertSyntax: true` option in the import attributes plugin to suppress this error.\",\n  ImportBindingIsString: ({ importName }: { importName: string }) =>\n    `A string literal cannot be used as an imported binding.\\n- Did you mean \\`import { \"${importName}\" as foo }\\`?`,\n  ImportCallArgumentTrailingComma:\n    \"Trailing comma is disallowed inside import(...) arguments.\",\n  ImportCallArity: ({ maxArgumentCount }: { maxArgumentCount: 1 | 2 }) =>\n    `\\`import()\\` requires exactly ${\n      maxArgumentCount === 1 ? \"one argument\" : \"one or two arguments\"\n    }.`,\n  ImportCallNotNewExpression: \"Cannot use new with import(...).\",\n  ImportCallSpreadArgument: \"`...` is not allowed in `import()`.\",\n  ImportJSONBindingNotDefault:\n    \"A JSON module can only be imported with `default`.\",\n  ImportReflectionHasAssertion: \"`import module x` cannot have assertions.\",\n  ImportReflectionNotBinding:\n    'Only `import module x from \"./module\"` is valid.',\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: ({ radix }: { radix: number }) =>\n    `Expected number in radix ${radix}.`,\n  InvalidEscapeSequence: \"Bad character escape sequence.\",\n  InvalidEscapeSequenceTemplate: \"Invalid escape sequence in template.\",\n  InvalidEscapedReservedWord: ({ reservedWord }: { reservedWord: string }) =>\n    `Escape sequence in keyword ${reservedWord}.`,\n  InvalidIdentifier: ({ identifierName }: { identifierName: string }) =>\n    `Invalid identifier ${identifierName}.`,\n  InvalidLhs: ({ ancestor }: { ancestor: LValAncestor }) =>\n    `Invalid left-hand side in ${toNodeDescription(ancestor)}.`,\n  InvalidLhsBinding: ({ ancestor }: { ancestor: LValAncestor }) =>\n    `Binding invalid left-hand side in ${toNodeDescription(ancestor)}.`,\n  InvalidNumber: \"Invalid number.\",\n  InvalidOrMissingExponent:\n    \"Floating-point numbers require a valid exponent after the 'e'.\",\n  InvalidOrUnexpectedToken: ({ unexpected }: { unexpected: string }) =>\n    `Unexpected character '${unexpected}'.`,\n  InvalidParenthesizedAssignment: \"Invalid parenthesized assignment pattern.\",\n  InvalidPrivateFieldResolution: ({\n    identifierName,\n  }: {\n    identifierName: string;\n  }) => `Private name #${identifierName} 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: ({ labelName }: { labelName: string }) =>\n    `Label '${labelName}' 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  MissingPlugin: ({ missingPlugin }: { missingPlugin: [string] }) =>\n    `This experimental syntax requires enabling the parser plugin: ${missingPlugin\n      .map(name => JSON.stringify(name))\n      .join(\", \")}.`,\n  // FIXME: Would be nice to make this \"missingPlugins\" instead.\n  // Also, seems like we can drop the \"(s)\" from the message and just make it \"s\".\n  MissingOneOfPlugins: ({ missingPlugin }: { missingPlugin: string[] }) =>\n    `This experimental syntax requires enabling one of the following parser plugin(s): ${missingPlugin\n      .map(name => JSON.stringify(name))\n      .join(\", \")}.`,\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: ({ key }: { key: string }) =>\n    `Duplicate key \"${key}\" is not allowed in module attributes.`,\n  ModuleExportNameHasLoneSurrogate: ({\n    surrogateCharCode,\n  }: {\n    surrogateCharCode: number;\n  }) =>\n    `An export name cannot include a lone surrogate, found '\\\\u${surrogateCharCode.toString(\n      16,\n    )}'.`,\n  ModuleExportUndefined: ({ localName }: { localName: string }) =>\n    `Export '${localName}' 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  PrivateInExpectedIn: ({ identifierName }: { identifierName: string }) =>\n    `Private names are only allowed in property accesses (\\`obj.#${identifierName}\\`) or in \\`in\\` expressions (\\`#${identifierName} in obj\\`).`,\n  PrivateNameRedeclaration: ({ identifierName }: { identifierName: string }) =>\n    `Duplicate private name #${identifierName}.`,\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 or inside a block.\",\n  SloppyFunctionAnnexB:\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  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: ({ keyword }: { keyword: string }) =>\n    `Unexpected keyword '${keyword}'.`,\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: ({ reservedWord }: { reservedWord: string }) =>\n    `Unexpected reserved word '${reservedWord}'.`,\n  UnexpectedSuper: \"'super' is only allowed in object methods and classes.\",\n  UnexpectedToken: ({\n    expected,\n    unexpected,\n  }: {\n    expected?: string | null;\n    unexpected?: string | null;\n  }) =>\n    `Unexpected token${unexpected ? ` '${unexpected}'.` : \"\"}${\n      expected ? `, expected \"${expected}\"` : \"\"\n    }`,\n  UnexpectedTokenUnaryExponentiation:\n    \"Illegal expression. Wrap left hand side or entire exponentiation in parentheses.\",\n  UnexpectedUsingDeclaration:\n    \"Using declaration cannot appear in the top level when source type is `script`.\",\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: ({\n    target,\n    onlyValidPropertyName,\n  }: {\n    target: string;\n    onlyValidPropertyName: string;\n  }) =>\n    `The only valid meta property for ${target} is ${target}.${onlyValidPropertyName}.`,\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  UsingDeclarationHasBindingPattern:\n    \"Using declaration cannot have destructuring patterns.\",\n  VarRedeclaration: ({ identifierName }: { identifierName: string }) =>\n    `Identifier '${identifierName}' 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"],"mappings":"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"}����������������������������������������������������������������������������������������lib/parse-error/strict-mode-errors.js���������������������������������������������������������������0000644�����������������00000001401�15120211212�0013634 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;
var _default = {
  StrictDelete: "Deleting local variable in strict mode.",
  StrictEvalArguments: ({
    referenceName
  }) => `Assigning to '${referenceName}' in strict mode.`,
  StrictEvalArgumentsBinding: ({
    bindingName
  }) => `Binding '${bindingName}' 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."
};
exports.default = _default;

//# sourceMappingURL=strict-mode-errors.js.map
���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������lib/parse-error/strict-mode-errors.js.map�����������������������������������������������������������0000644�����������������00000003747�15120211212�0014427 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������{"version":3,"names":["StrictDelete","StrictEvalArguments","referenceName","StrictEvalArgumentsBinding","bindingName","StrictFunction","StrictNumericEscape","StrictOctalLiteral","StrictWith","exports","default","_default"],"sources":["../../src/parse-error/strict-mode-errors.ts"],"sourcesContent":["export default {\n  StrictDelete: \"Deleting local variable in strict mode.\",\n\n  // `referenceName` is the StringValue[1] of an IdentifierReference[2], which\n  // is represented as just an `Identifier`[3] in the Babel AST.\n  // 1. https://tc39.es/ecma262/#sec-static-semantics-stringvalue\n  // 2. https://tc39.es/ecma262/#prod-IdentifierReference\n  // 3. https://github.com/babel/babel/blob/main/packages/babel-parser/ast/spec.md#identifier\n  StrictEvalArguments: ({ referenceName }: { referenceName: string }) =>\n    `Assigning to '${referenceName}' in strict mode.`,\n\n  // `bindingName` is the StringValue[1] of a BindingIdentifier[2], which is\n  // represented as just an `Identifier`[3] in the Babel AST.\n  // 1. https://tc39.es/ecma262/#sec-static-semantics-stringvalue\n  // 2. https://tc39.es/ecma262/#prod-BindingIdentifier\n  // 3. https://github.com/babel/babel/blob/main/packages/babel-parser/ast/spec.md#identifier\n  StrictEvalArgumentsBinding: ({ bindingName }: { bindingName: string }) =>\n    `Binding '${bindingName}' in strict mode.`,\n\n  StrictFunction:\n    \"In strict mode code, functions can only be declared at top level or inside a block.\",\n\n  StrictNumericEscape: \"The only valid numeric escape in strict mode is '\\\\0'.\",\n\n  StrictOctalLiteral: \"Legacy octal literals are not allowed in strict mode.\",\n\n  StrictWith: \"'with' in strict mode.\",\n};\n"],"mappings":";;;;;;eAAe;EACbA,YAAY,EAAE,yCAAyC;EAOvDC,mBAAmB,EAAEA,CAAC;IAAEC;EAAyC,CAAC,KAC/D,iBAAgBA,aAAc,mBAAkB;EAOnDC,0BAA0B,EAAEA,CAAC;IAAEC;EAAqC,CAAC,KAClE,YAAWA,WAAY,mBAAkB;EAE5CC,cAAc,EACZ,qFAAqF;EAEvFC,mBAAmB,EAAE,wDAAwD;EAE7EC,kBAAkB,EAAE,uDAAuD;EAE3EC,UAAU,EAAE;AACd,CAAC;AAAAC,OAAA,CAAAC,OAAA,GAAAC,QAAA"}�������������������������lib/parse-error/to-node-description.js��������������������������������������������������������������0000644�����������������00000002452�15120211212�0013765 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;
const NodeDescriptions = {
  ArrayPattern: "array destructuring pattern",
  AssignmentExpression: "assignment expression",
  AssignmentPattern: "assignment expression",
  ArrowFunctionExpression: "arrow function expression",
  ConditionalExpression: "conditional expression",
  CatchClause: "catch clause",
  ForOfStatement: "for-of statement",
  ForInStatement: "for-in statement",
  ForStatement: "for-loop",
  FormalParameters: "function parameter list",
  Identifier: "identifier",
  ImportSpecifier: "import specifier",
  ImportDefaultSpecifier: "import default specifier",
  ImportNamespaceSpecifier: "import namespace specifier",
  ObjectPattern: "object destructuring pattern",
  ParenthesizedExpression: "parenthesized expression",
  RestElement: "rest element",
  UpdateExpression: {
    true: "prefix operation",
    false: "postfix operation"
  },
  VariableDeclarator: "variable declaration",
  YieldExpression: "yield expression"
};
const toNodeDescription = ({
  type,
  prefix
}) => type === "UpdateExpression" ? NodeDescriptions.UpdateExpression[String(prefix)] : NodeDescriptions[type];
var _default = toNodeDescription;
exports.default = _default;

//# sourceMappingURL=to-node-description.js.map
����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������lib/parse-error/to-node-description.js.map����������������������������������������������������������0000644�����������������00000006004�15120211212�0014536 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������{"version":3,"names":["NodeDescriptions","ArrayPattern","AssignmentExpression","AssignmentPattern","ArrowFunctionExpression","ConditionalExpression","CatchClause","ForOfStatement","ForInStatement","ForStatement","FormalParameters","Identifier","ImportSpecifier","ImportDefaultSpecifier","ImportNamespaceSpecifier","ObjectPattern","ParenthesizedExpression","RestElement","UpdateExpression","true","false","VariableDeclarator","YieldExpression","toNodeDescription","type","prefix","String","_default","exports","default"],"sources":["../../src/parse-error/to-node-description.ts"],"sourcesContent":["const NodeDescriptions = {\n  ArrayPattern: \"array destructuring pattern\",\n  AssignmentExpression: \"assignment expression\",\n  AssignmentPattern: \"assignment expression\",\n  ArrowFunctionExpression: \"arrow function expression\",\n  ConditionalExpression: \"conditional expression\",\n  CatchClause: \"catch clause\",\n  ForOfStatement: \"for-of statement\",\n  ForInStatement: \"for-in statement\",\n  ForStatement: \"for-loop\",\n  FormalParameters: \"function parameter list\",\n  Identifier: \"identifier\",\n  ImportSpecifier: \"import specifier\",\n  ImportDefaultSpecifier: \"import default specifier\",\n  ImportNamespaceSpecifier: \"import namespace specifier\",\n  ObjectPattern: \"object destructuring pattern\",\n  ParenthesizedExpression: \"parenthesized expression\",\n  RestElement: \"rest element\",\n  UpdateExpression: {\n    true: \"prefix operation\",\n    false: \"postfix operation\",\n  },\n  VariableDeclarator: \"variable declaration\",\n  YieldExpression: \"yield expression\",\n};\n\ntype NodeTypesWithDescriptions = keyof Omit<\n  typeof NodeDescriptions,\n  \"UpdateExpression\"\n>;\n\ntype NodeWithDescription =\n  | {\n      type: \"UpdateExpression\";\n      prefix: boolean;\n    }\n  | {\n      type: NodeTypesWithDescriptions;\n    };\n\n// @ts-expect-error prefix is specified only when type is UpdateExpression\n// eslint-disable-next-line no-confusing-arrow\nconst toNodeDescription = ({ type, prefix }: NodeWithDescription) =>\n  type === \"UpdateExpression\"\n    ? NodeDescriptions.UpdateExpression[String(prefix) as \"true\" | \"false\"]\n    : NodeDescriptions[type];\n\nexport default toNodeDescription;\n"],"mappings":";;;;;;AAAA,MAAMA,gBAAgB,GAAG;EACvBC,YAAY,EAAE,6BAA6B;EAC3CC,oBAAoB,EAAE,uBAAuB;EAC7CC,iBAAiB,EAAE,uBAAuB;EAC1CC,uBAAuB,EAAE,2BAA2B;EACpDC,qBAAqB,EAAE,wBAAwB;EAC/CC,WAAW,EAAE,cAAc;EAC3BC,cAAc,EAAE,kBAAkB;EAClCC,cAAc,EAAE,kBAAkB;EAClCC,YAAY,EAAE,UAAU;EACxBC,gBAAgB,EAAE,yBAAyB;EAC3CC,UAAU,EAAE,YAAY;EACxBC,eAAe,EAAE,kBAAkB;EACnCC,sBAAsB,EAAE,0BAA0B;EAClDC,wBAAwB,EAAE,4BAA4B;EACtDC,aAAa,EAAE,8BAA8B;EAC7CC,uBAAuB,EAAE,0BAA0B;EACnDC,WAAW,EAAE,cAAc;EAC3BC,gBAAgB,EAAE;IAChBC,IAAI,EAAE,kBAAkB;IACxBC,KAAK,EAAE;EACT,CAAC;EACDC,kBAAkB,EAAE,sBAAsB;EAC1CC,eAAe,EAAE;AACnB,CAAC;AAkBD,MAAMC,iBAAiB,GAAGA,CAAC;EAAEC,IAAI;EAAEC;AAA4B,CAAC,KAC9DD,IAAI,KAAK,kBAAkB,GACvBxB,gBAAgB,CAACkB,gBAAgB,CAACQ,MAAM,CAACD,MAAM,CAAC,CAAqB,GACrEzB,gBAAgB,CAACwB,IAAI,CAAC;AAAC,IAAAG,QAAA,GAEdJ,iBAAiB;AAAAK,OAAA,CAAAC,OAAA,GAAAF,QAAA"}����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������lib/parser/base.js����������������������������������������������������������������������������������0000644�����������������00000001742�15120211212�0010045 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;
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];
  }
}
exports.default = BaseParser;

//# sourceMappingURL=base.js.map
������������������������������lib/parser/base.js.map������������������������������������������������������������������������������0000644�����������������00000007235�15120211212�0010624 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������{"version":3,"names":["BaseParser","constructor","sawUnambiguousESM","ambiguousScriptDifferentAst","hasPlugin","pluginConfig","plugins","has","pluginName","pluginOptions","actualOptions","get","key","Object","keys","getPluginOption","plugin","name","_this$plugins$get","exports","default"],"sources":["../../src/parser/base.ts"],"sourcesContent":["import 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\";\nimport type {\n  ParserPluginWithOptions,\n  PluginConfig,\n  PluginOptions,\n} from \"../typings\";\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<any>;\n  declare classScope: ClassScopeHandler;\n  declare prodParam: ProductionParameterHandler;\n  declare expressionScope: ExpressionScopeHandler;\n  declare plugins: PluginsMap;\n  declare filename: string | undefined | null;\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<string>;\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(\n        pluginOptions,\n      ) as (keyof typeof pluginOptions)[]) {\n        if (actualOptions?.[key] !== pluginOptions[key]) {\n          return false;\n        }\n      }\n      return true;\n    }\n  }\n\n  getPluginOption<\n    PluginName extends ParserPluginWithOptions[0],\n    OptionName extends keyof PluginOptions<PluginName>,\n  >(plugin: PluginName, name: OptionName) {\n    return (this.plugins.get(plugin) as null | PluginOptions<PluginName>)?.[\n      name\n    ];\n  }\n}\n"],"mappings":";;;;;;AAae,MAAMA,UAAU,CAAC;EAAAC,YAAA;IAAA,KAa9BC,iBAAiB,GAAY,KAAK;IAAA,KAClCC,2BAA2B,GAAY,KAAK;EAAA;EAa5CC,SAASA,CAACC,YAA0B,EAAW;IAC7C,IAAI,OAAOA,YAAY,KAAK,QAAQ,EAAE;MACpC,OAAO,IAAI,CAACC,OAAO,CAACC,GAAG,CAACF,YAAY,CAAC;IACvC,CAAC,MAAM;MACL,MAAM,CAACG,UAAU,EAAEC,aAAa,CAAC,GAAGJ,YAAY;MAChD,IAAI,CAAC,IAAI,CAACD,SAAS,CAACI,UAAU,CAAC,EAAE;QAC/B,OAAO,KAAK;MACd;MACA,MAAME,aAAa,GAAG,IAAI,CAACJ,OAAO,CAACK,GAAG,CAACH,UAAU,CAAC;MAClD,KAAK,MAAMI,GAAG,IAAIC,MAAM,CAACC,IAAI,CAC3BL,aACF,CAAC,EAAoC;QACnC,IAAI,CAAAC,aAAa,oBAAbA,aAAa,CAAGE,GAAG,CAAC,MAAKH,aAAa,CAACG,GAAG,CAAC,EAAE;UAC/C,OAAO,KAAK;QACd;MACF;MACA,OAAO,IAAI;IACb;EACF;EAEAG,eAAeA,CAGbC,MAAkB,EAAEC,IAAgB,EAAE;IAAA,IAAAC,iBAAA;IACtC,QAAAA,iBAAA,GAAQ,IAAI,CAACZ,OAAO,CAACK,GAAG,CAACK,MAAM,CAAC,qBAAzBE,iBAAA,CACLD,IAAI,CACL;EACH;AACF;AAACE,OAAA,CAAAC,OAAA,GAAApB,UAAA"}�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������lib/parser/comments.js������������������������������������������������������������������������������0000644�����������������00000012566�15120211212�0010766 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;
exports.setInnerComments = setInnerComments;
var _base = require("./base");
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 _base.default {
  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;
    }
  }
  resetPreviousIdentifierLeadingComments(node) {
    const {
      commentStack
    } = this.state;
    const {
      length
    } = commentStack;
    if (length === 0) return;
    if (commentStack[length - 1].trailingNode === node) {
      commentStack[length - 1].trailingNode = null;
    } else if (length >= 2 && commentStack[length - 2].trailingNode === node) {
      commentStack[length - 2].trailingNode = 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;
      }
    }
  }
}
exports.default = CommentsParser;

//# sourceMappingURL=comments.js.map
������������������������������������������������������������������������������������������������������������������������������������������lib/parser/comments.js.map��������������������������������������������������������������������������0000644�����������������00000040465�15120211212�0011541 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������{"version":3,"names":["_base","require","setTrailingComments","node","comments","trailingComments","undefined","unshift","setLeadingComments","leadingComments","setInnerComments","innerComments","adjustInnerComments","elements","commentWS","lastElement","i","length","start","CommentsParser","BaseParser","addComment","comment","filename","loc","state","push","processComment","commentStack","commentStackLength","lastCommentWS","end","leadingNode","nodeStart","commentEnd","containingNode","finalizeComment","splice","trailingNode","commentStart","input","charCodeAt","type","properties","arguments","params","specifiers","finalizeRemainingComments","resetPreviousNodeTrailingComments","resetPreviousIdentifierLeadingComments","takeSurroundingComments","exports","default"],"sources":["../../src/parser/comments.ts"],"sourcesContent":["/*:: declare var invariant; */\n\nimport BaseParser from \"./base\";\nimport type { Comment, Node, Identifier } from \"../types\";\nimport * as charCodes from \"charcodes\";\nimport type { Undone } from \"./node\";\n\n/**\n * A whitespace token containing comments\n */\nexport type CommentWhitespace = {\n  /**\n   * the start of the whitespace token.\n   */\n  start: number;\n  /**\n   * the end of the whitespace token.\n   */\n  end: number;\n  /**\n   * the containing comments\n   */\n  comments: Array<Comment>;\n  /**\n   * the immediately preceding AST node of the whitespace token\n   */\n  leadingNode: Node | null;\n  /**\n   * the immediately following AST node of the whitespace token\n   */\n  trailingNode: Node | null;\n  /**\n   * the innermost AST node containing the whitespace with minimal size (|end - start|)\n   */\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 */\nfunction setTrailingComments(node: Undone<Node>, comments: Array<Comment>) {\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 */\nfunction setLeadingComments(node: Undone<Node>, comments: Array<Comment>) {\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 */\nexport function setInnerComments(\n  node: Undone<Node>,\n  comments?: Array<Comment>,\n) {\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 */\nfunction adjustInnerComments(\n  node: Undone<Node>,\n  elements: Array<Node>,\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\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  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  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 remaining 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  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  /* eslint-disable no-irregular-whitespace */\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 reinterpret 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   * ```\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 node the last finished AST node _before_ current token\n   */\n  /* eslint-enable no-irregular-whitespace */\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  /* eslint-disable no-irregular-whitespace */\n  /**\n   * Reset previous node leading comments, assuming that `node` is a\n   * single-token node. Used in import phase modifiers parsing. We parse\n   * `module` in `import module foo from ...` as an identifier but may\n   * reinterpret it into a phase modifier later. In this case the identifier is\n   * not part of the AST and we should sync the knowledge to commentStacks\n   *\n   * For example, when parsing\n   * ```\n   * import /* 1 */ module a from \"a\";\n   * ```\n   * the comment whitespace `/* 1 */` has trailing node Identifier(module). When\n   * we see that `module` is not a default import binding, we mark `/* 1 */` as\n   * inner comments of the ImportDeclaration. So `/* 1 */` should be detached from\n   * the Identifier node.\n   *\n   * @param node the last finished AST node _before_ current token\n   */\n  /* eslint-enable no-irregular-whitespace */\n  resetPreviousIdentifierLeadingComments(node: Identifier) {\n    const { commentStack } = this.state;\n    const { length } = commentStack;\n    if (length === 0) return;\n\n    if (commentStack[length - 1].trailingNode === node) {\n      commentStack[length - 1].trailingNode = null;\n    } else if (length >= 2 && commentStack[length - 2].trailingNode === node) {\n      commentStack[length - 2].trailingNode = 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  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"],"mappings":"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"}�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������lib/parser/expression.js����������������������������������������������������������������������������0000644�����������������00000172377�15120211212�0011347 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;
var _types = require("../tokenizer/types");
var _lval = require("./lval");
var _identifier = require("../util/identifier");
var _location = require("../util/location");
var _scopeflags = require("../util/scopeflags");
var _util = require("./util");
var _productionParameter = require("../util/production-parameter");
var _expressionScope = require("../util/expression-scope");
var _parseError = require("../parse-error");
var _pipelineOperatorErrors = require("../parse-error/pipeline-operator-errors");
var _comments = require("./comments");
var _node = require("./node");
class ExpressionParser extends _lval.default {
  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(_parseError.Errors.RecordNoProto, {
          at: key
        });
        return;
      }
      if (protoRef.used) {
        if (refExpressionErrors) {
          if (refExpressionErrors.doubleProtoLoc === null) {
            refExpressionErrors.doubleProtoLoc = key.loc.start;
          }
        } else {
          this.raise(_parseError.Errors.DuplicateProto, {
            at: 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(137)) {
      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 startLoc = this.state.startLoc;
    const expr = this.parseMaybeAssign(refExpressionErrors);
    if (this.match(12)) {
      const node = this.startNodeAt(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 startLoc = this.state.startLoc;
    if (this.isContextual(106)) {
      if (this.prodParam.hasYield) {
        let left = this.parseYield();
        if (afterLeftParse) {
          left = afterLeftParse.call(this, left, startLoc);
        }
        return left;
      }
    }
    let ownExpressionErrors;
    if (refExpressionErrors) {
      ownExpressionErrors = false;
    } else {
      refExpressionErrors = new _util.ExpressionErrors();
      ownExpressionErrors = true;
    }
    const {
      type
    } = this.state;
    if (type === 10 || (0, _types.tokenIsIdentifier)(type)) {
      this.state.potentialArrowAt = this.state.start;
    }
    let left = this.parseMaybeConditional(refExpressionErrors);
    if (afterLeftParse) {
      left = afterLeftParse.call(this, left, startLoc);
    }
    if ((0, _types.tokenIsAssignment)(this.state.type)) {
      const node = this.startNodeAt(startLoc);
      const operator = this.state.value;
      node.operator = operator;
      if (this.match(29)) {
        this.toAssignable(left, true);
        node.left = left;
        const startIndex = startLoc.index;
        if (refExpressionErrors.doubleProtoLoc != null && refExpressionErrors.doubleProtoLoc.index >= startIndex) {
          refExpressionErrors.doubleProtoLoc = null;
        }
        if (refExpressionErrors.shorthandAssignLoc != null && refExpressionErrors.shorthandAssignLoc.index >= startIndex) {
          refExpressionErrors.shorthandAssignLoc = null;
        }
        if (refExpressionErrors.privateKeyLoc != null && refExpressionErrors.privateKeyLoc.index >= startIndex) {
          this.checkDestructuringPrivate(refExpressionErrors);
          refExpressionErrors.privateKeyLoc = null;
        }
      } else {
        node.left = left;
      }
      this.next();
      node.right = this.parseMaybeAssign();
      this.checkLVal(left, {
        in: this.finishNode(node, "AssignmentExpression")
      });
      return node;
    } else if (ownExpressionErrors) {
      this.checkExpressionErrors(refExpressionErrors, true);
    }
    return left;
  }
  parseMaybeConditional(refExpressionErrors) {
    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, startLoc, refExpressionErrors);
  }
  parseConditional(expr, startLoc, refExpressionErrors) {
    if (this.eat(17)) {
      const node = this.startNodeAt(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(136) ? this.parsePrivateName() : this.parseMaybeUnary(refExpressionErrors);
  }
  parseExprOps(refExpressionErrors) {
    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, startLoc, -1);
  }
  parseExprOp(left, leftStartLoc, minPrec) {
    if (this.isPrivateName(left)) {
      const value = this.getPrivateNameSV(left);
      if (minPrec >= (0, _types.tokenOperatorPrecedence)(58) || !this.prodParam.hasIn || !this.match(58)) {
        this.raise(_parseError.Errors.PrivateInExpectedIn, {
          at: left,
          identifierName: value
        });
      }
      this.classScope.usePrivateName(value, left.loc.start);
    }
    const op = this.state.type;
    if ((0, _types.tokenIsOperator)(op) && (this.prodParam.hasIn || !this.match(58))) {
      let prec = (0, _types.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(leftStartLoc);
        node.left = left;
        node.operator = this.state.value;
        const logical = op === 41 || op === 42;
        const coalesce = op === 40;
        if (coalesce) {
          prec = (0, _types.tokenOperatorPrecedence)(42);
        }
        this.next();
        if (op === 39 && this.hasPlugin(["pipelineOperator", {
          proposal: "minimal"
        }])) {
          if (this.state.type === 96 && this.prodParam.hasAwait) {
            throw this.raise(_parseError.Errors.UnexpectedAwaitAfterPipelineBody, {
              at: this.state.startLoc
            });
          }
        }
        node.right = this.parseExprOpRightExpr(op, prec);
        const finishedNode = this.finishNode(node, logical || coalesce ? "LogicalExpression" : "BinaryExpression");
        const nextOp = this.state.type;
        if (coalesce && (nextOp === 41 || nextOp === 42) || logical && nextOp === 40) {
          throw this.raise(_parseError.Errors.MixingCoalesceWithLogical, {
            at: this.state.startLoc
          });
        }
        return this.parseExprOp(finishedNode, leftStartLoc, minPrec);
      }
    }
    return left;
  }
  parseExprOpRightExpr(op, prec) {
    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(106)) {
                throw this.raise(_parseError.Errors.PipeBodyIsTighter, {
                  at: this.state.startLoc
                });
              }
              return this.parseSmartPipelineBodyInStyle(this.parseExprOpBaseRightExpr(op, prec), startLoc);
            });
          case "fsharp":
            return this.withSoloAwaitPermittingContext(() => {
              return this.parseFSharpPipelineBody(prec);
            });
        }
      default:
        return this.parseExprOpBaseRightExpr(op, prec);
    }
  }
  parseExprOpBaseRightExpr(op, prec) {
    const startLoc = this.state.startLoc;
    return this.parseExprOp(this.parseMaybeUnaryOrPrivate(), startLoc, (0, _types.tokenIsRightAssociative)(op) ? prec - 1 : prec);
  }
  parseHackPipeBody() {
    var _body$extra;
    const {
      startLoc
    } = this.state;
    const body = this.parseMaybeAssign();
    const requiredParentheses = _pipelineOperatorErrors.UnparenthesizedPipeBodyDescriptions.has(body.type);
    if (requiredParentheses && !((_body$extra = body.extra) != null && _body$extra.parenthesized)) {
      this.raise(_parseError.Errors.PipeUnparenthesizedBody, {
        at: startLoc,
        type: body.type
      });
    }
    if (!this.topicReferenceWasUsedInCurrentContext()) {
      this.raise(_parseError.Errors.PipeTopicUnused, {
        at: startLoc
      });
    }
    return body;
  }
  checkExponentialAfterUnary(node) {
    if (this.match(57)) {
      this.raise(_parseError.Errors.UnexpectedTokenUnaryExponentiation, {
        at: node.argument
      });
    }
  }
  parseMaybeUnary(refExpressionErrors, sawUnary) {
    const startLoc = this.state.startLoc;
    const isAwait = this.isContextual(96);
    if (isAwait && this.isAwaitAllowed()) {
      this.next();
      const expr = this.parseAwait(startLoc);
      if (!sawUnary) this.checkExponentialAfterUnary(expr);
      return expr;
    }
    const update = this.match(34);
    const node = this.startNode();
    if ((0, _types.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(_parseError.Errors.StrictDelete, {
            at: node
          });
        } else if (this.hasPropertyAsPrivateName(arg)) {
          this.raise(_parseError.Errors.DeletePrivateField, {
            at: 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") ? (0, _types.tokenCanStartExpression)(type) : (0, _types.tokenCanStartExpression)(type) && !this.match(54);
      if (startsExpr && !this.isAmbiguousAwait()) {
        this.raiseOverwrite(_parseError.Errors.AwaitNotInAsyncContext, {
          at: startLoc
        });
        return this.parseAwait(startLoc);
      }
    }
    return expr;
  }
  parseUpdate(node, update, refExpressionErrors) {
    if (update) {
      const updateExpressionNode = node;
      this.checkLVal(updateExpressionNode.argument, {
        in: this.finishNode(updateExpressionNode, "UpdateExpression")
      });
      return node;
    }
    const startLoc = this.state.startLoc;
    let expr = this.parseExprSubscripts(refExpressionErrors);
    if (this.checkExpressionErrors(refExpressionErrors, false)) return expr;
    while ((0, _types.tokenIsPostfix)(this.state.type) && !this.canInsertSemicolon()) {
      const node = this.startNodeAt(startLoc);
      node.operator = this.state.value;
      node.prefix = false;
      node.argument = expr;
      this.next();
      this.checkLVal(expr, {
        in: expr = this.finishNode(node, "UpdateExpression")
      });
    }
    return expr;
  }
  parseExprSubscripts(refExpressionErrors) {
    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, startLoc);
  }
  parseSubscripts(base, startLoc, noCalls) {
    const state = {
      optionalChainMember: false,
      maybeAsyncArrow: this.atPossibleAsyncArrow(base),
      stop: false
    };
    do {
      base = this.parseSubscript(base, startLoc, noCalls, state);
      state.maybeAsyncArrow = false;
    } while (!state.stop);
    return base;
  }
  parseSubscript(base, startLoc, noCalls, state) {
    const {
      type
    } = this.state;
    if (!noCalls && type === 15) {
      return this.parseBind(base, startLoc, noCalls, state);
    } else if ((0, _types.tokenIsTemplate)(type)) {
      return this.parseTaggedTemplateExpression(base, startLoc, state);
    }
    let optional = false;
    if (type === 18) {
      if (noCalls) {
        this.raise(_parseError.Errors.OptionalChainingNoNew, {
          at: this.state.startLoc
        });
        if (this.lookaheadCharCode() === 40) {
          state.stop = true;
          return base;
        }
      }
      state.optionalChainMember = optional = true;
      this.next();
    }
    if (!noCalls && this.match(10)) {
      return this.parseCoverCallAndAsyncArrowHead(base, startLoc, state, optional);
    } else {
      const computed = this.eat(0);
      if (computed || optional || this.eat(16)) {
        return this.parseMember(base, startLoc, state, computed, optional);
      } else {
        state.stop = true;
        return base;
      }
    }
  }
  parseMember(base, startLoc, state, computed, optional) {
    const node = this.startNodeAt(startLoc);
    node.object = base;
    node.computed = computed;
    if (computed) {
      node.property = this.parseExpression();
      this.expect(3);
    } else if (this.match(136)) {
      if (base.type === "Super") {
        this.raise(_parseError.Errors.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, startLoc, noCalls, state) {
    const node = this.startNodeAt(startLoc);
    node.object = base;
    this.next();
    node.callee = this.parseNoCallExpr();
    state.stop = true;
    return this.parseSubscripts(this.finishNode(node, "BindExpression"), startLoc, noCalls);
  }
  parseCoverCallAndAsyncArrowHead(base, startLoc, state, optional) {
    const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;
    let refExpressionErrors = null;
    this.state.maybeInArrowParameters = true;
    this.next();
    const node = this.startNodeAt(startLoc);
    node.callee = base;
    const {
      maybeAsyncArrow,
      optionalChainMember
    } = state;
    if (maybeAsyncArrow) {
      this.expressionScope.enter((0, _expressionScope.newAsyncArrowScope)());
      refExpressionErrors = new _util.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);
    }
    let finishedNode = this.finishCallExpression(node, optionalChainMember);
    if (maybeAsyncArrow && this.shouldParseAsyncArrow() && !optional) {
      state.stop = true;
      this.checkDestructuringPrivate(refExpressionErrors);
      this.expressionScope.validateAsPattern();
      this.expressionScope.exit();
      finishedNode = this.parseAsyncArrowFromCallExpression(this.startNodeAt(startLoc), finishedNode);
    } else {
      if (maybeAsyncArrow) {
        this.checkExpressionErrors(refExpressionErrors, true);
        this.expressionScope.exit();
      }
      this.toReferencedArguments(finishedNode);
    }
    this.state.maybeInArrowParameters = oldMaybeInArrowParameters;
    return finishedNode;
  }
  toReferencedArguments(node, isParenthesizedExpr) {
    this.toReferencedListDeep(node.arguments, isParenthesizedExpr);
  }
  parseTaggedTemplateExpression(base, startLoc, state) {
    const node = this.startNodeAt(startLoc);
    node.tag = base;
    node.quasi = this.parseTemplate(true);
    if (state.optionalChainMember) {
      this.raise(_parseError.Errors.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;
  }
  expectImportAttributesPlugin() {
    if (!this.hasPlugin("importAssertions")) {
      this.expectPlugin("importAttributes");
    }
  }
  finishCallExpression(node, optional) {
    if (node.callee.type === "Import") {
      if (node.arguments.length === 2) {
        {
          if (!this.hasPlugin("moduleAttributes")) {
            this.expectImportAttributesPlugin();
          }
        }
      }
      if (node.arguments.length === 0 || node.arguments.length > 2) {
        this.raise(_parseError.Errors.ImportCallArity, {
          at: node,
          maxArgumentCount: this.hasPlugin("importAttributes") || this.hasPlugin("importAssertions") || this.hasPlugin("moduleAttributes") ? 2 : 1
        });
      } else {
        for (const arg of node.arguments) {
          if (arg.type === "SpreadElement") {
            this.raise(_parseError.Errors.ImportCallSpreadArgument, {
              at: 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("importAttributes") && !this.hasPlugin("importAssertions") && !this.hasPlugin("moduleAttributes")) {
            this.raise(_parseError.Errors.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) {
      (0, _comments.setInnerComments)(node, call.innerComments);
    }
    if (call.callee.trailingComments) {
      (0, _comments.setInnerComments)(node, call.callee.trailingComments);
    }
    return node;
  }
  parseNoCallExpr() {
    const startLoc = this.state.startLoc;
    return this.parseSubscripts(this.parseExprAtom(), startLoc, true);
  }
  parseExprAtom(refExpressionErrors) {
    let node;
    let decorators = null;
    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(_parseError.Errors.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 132:
        return this.parseNumericLiteral(this.state.value);
      case 133:
        return this.parseBigIntLiteral(this.state.value);
      case 134:
        return this.parseDecimalLiteral(this.state.value);
      case 131:
        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:
        decorators = this.parseDecorators();
      case 80:
        return this.parseClass(this.maybeTakeDecorators(decorators, this.startNode()), 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(_parseError.Errors.UnsupportedBind, {
              at: callee
            });
          }
        }
      case 136:
        {
          this.raise(_parseError.Errors.PrivateInExpectedIn, {
            at: this.state.startLoc,
            identifierName: 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);
          }
          this.unexpected();
          break;
        }
      case 47:
        {
          const lookaheadCh = this.input.codePointAt(this.nextTokenStart());
          if ((0, _identifier.isIdentifierStart)(lookaheadCh) || lookaheadCh === 62) {
            this.expectOnePlugin(["jsx", "flow", "typescript"]);
          } else {
            this.unexpected();
          }
          break;
        }
      default:
        if ((0, _types.tokenIsIdentifier)(type)) {
          if (this.isContextual(125) && this.lookaheadInLineCharCode() === 123) {
            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.parseAsyncFunctionExpression(this.startNodeAtNode(id));
            } else if ((0, _types.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 {
          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 = (0, _location.createPositionWithColumnOffset)(this.state.endLoc, -1);
      return this.parseTopicReference(pipeProposal);
    } else {
      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" ? _parseError.Errors.PrimaryTopicNotAllowed : _parseError.Errors.PipeTopicUnbound, {
          at: startLoc
        });
      }
      this.registerTopicReference();
      return this.finishNode(node, nodeType);
    } else {
      throw this.raise(_parseError.Errors.PipeTopicUnconfiguredToken, {
        at: startLoc,
        token: (0, _types.tokenLabelName)(tokenType)
      });
    }
  }
  testTopicReferenceConfiguration(pipeProposal, startLoc, tokenType) {
    switch (pipeProposal) {
      case "hack":
        {
          return this.hasPlugin(["pipelineOperator", {
            topicToken: (0, _types.tokenLabelName)(tokenType)
          }]);
        }
      case "smart":
        return tokenType === 27;
      default:
        throw this.raise(_parseError.Errors.PipeTopicRequiresHackPipes, {
          at: startLoc
        });
    }
  }
  parseAsyncArrowUnaryFunction(node) {
    this.prodParam.enter((0, _productionParameter.functionFlags)(true, this.prodParam.hasYield));
    const params = [this.parseIdentifier()];
    this.prodParam.exit();
    if (this.hasPrecedingLineBreak()) {
      this.raise(_parseError.Errors.LineTerminatorBeforeArrow, {
        at: this.state.curPosition()
      });
    }
    this.expect(19);
    return this.parseArrowExpression(node, params, true);
  }
  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(_productionParameter.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(_parseError.Errors.SuperNotAllowed, {
        at: node
      });
    } else if (!this.scope.allowSuper && !this.options.allowSuperOutsideMethod) {
      this.raise(_parseError.Errors.UnexpectedSuper, {
        at: node
      });
    }
    if (!this.match(10) && !this.match(0) && !this.match(16)) {
      this.raise(_parseError.Errors.UnsupportedSuper, {
        at: node
      });
    }
    return this.finishNode(node, "Super");
  }
  parsePrivateName() {
    const node = this.startNode();
    const id = this.startNodeAt((0, _location.createPositionWithColumnOffset)(this.state.startLoc, 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(_parseError.Errors.UnsupportedMetaProperty, {
        at: node.property,
        target: meta.name,
        onlyValidPropertyName: 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(_parseError.Errors.ImportMetaOutsideModule, {
          at: 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 startLoc = this.state.startLoc;
    let val;
    this.next();
    this.expressionScope.enter((0, _expressionScope.newArrowHeadScope)());
    const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;
    const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;
    this.state.maybeInArrowParameters = true;
    this.state.inFSharpPipelineDirectBody = false;
    const innerStartLoc = this.state.startLoc;
    const exprList = [];
    const refExpressionErrors = new _util.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 spreadNodeStartLoc = this.state.startLoc;
        spreadStartLoc = this.state.startLoc;
        exprList.push(this.parseParenItem(this.parseRestBinding(), 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(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(innerStartLoc);
      val.expressions = exprList;
      this.finishNode(val, "SequenceExpression");
      this.resetEndLocation(val, innerEndLoc);
    } else {
      val = exprList[0];
    }
    return this.wrapParenthesis(startLoc, val);
  }
  wrapParenthesis(startLoc, expression) {
    if (!this.options.createParenthesizedExpressions) {
      this.addExtra(expression, "parenthesized", true);
      this.addExtra(expression, "parenStart", startLoc.index);
      this.takeSurroundingComments(expression, startLoc.index, this.state.lastTokEndLoc.index);
      return expression;
    }
    const parenExpression = this.startNodeAt(startLoc);
    parenExpression.expression = expression;
    return this.finishNode(parenExpression, "ParenthesizedExpression");
  }
  shouldParseArrow(params) {
    return !this.canInsertSemicolon();
  }
  parseArrow(node) {
    if (this.eat(19)) {
      return node;
    }
  }
  parseParenItem(node, 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.options.allowNewTargetOutsideFunction) {
        this.raise(_parseError.Errors.UnexpectedNewTarget, {
          at: metaProp
        });
      }
      return metaProp;
    }
    return this.parseNew(node);
  }
  parseNew(node) {
    this.parseNewCallee(node);
    if (this.eat(10)) {
      const args = this.parseExprList(11);
      this.toReferencedList(args);
      node.arguments = args;
    } else {
      node.arguments = [];
    }
    return this.finishNode(node, "NewExpression");
  }
  parseNewCallee(node) {
    node.callee = this.parseNoCallExpr();
    if (node.callee.type === "Import") {
      this.raise(_parseError.Errors.ImportCallNotNewExpression, {
        at: node.callee
      });
    }
  }
  parseTemplateElement(isTagged) {
    const {
      start,
      startLoc,
      end,
      value
    } = this.state;
    const elemStart = start + 1;
    const elem = this.startNodeAt((0, _location.createPositionWithColumnOffset)(startLoc, 1));
    if (value === null) {
      if (!isTagged) {
        this.raise(_parseError.Errors.InvalidEscapeSequenceTemplate, {
          at: (0, _location.createPositionWithColumnOffset)(this.state.firstInvalidTemplateEscapePos, 1)
        });
      }
    }
    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();
    const finishedNode = this.finishNode(elem, "TemplateElement");
    this.resetEndLocation(finishedNode, (0, _location.createPositionWithColumnOffset)(this.state.lastTokEndLoc, endOffset));
    return finishedNode;
  }
  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(_parseError.Errors.InvalidRecordProperty, {
          at: 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(_parseError.Errors.UnsupportedPropertyDecorator, {
          at: this.state.startLoc
        });
      }
      while (this.match(26)) {
        decorators.push(this.parseDecorator());
      }
    }
    const prop = this.startNode();
    let isAsync = false;
    let isAccessor = false;
    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) {
      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(_parseError.Errors.AccessorIsGenerator, {
            at: this.state.curPosition(),
            kind: keyName
          });
          this.next();
        }
        this.parsePropertyName(prop);
      }
    }
    return this.parseObjPropValue(prop, startLoc, isGenerator, isAsync, false, isAccessor, refExpressionErrors);
  }
  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" ? _parseError.Errors.BadGetterArity : _parseError.Errors.BadSetterArity, {
        at: method
      });
    }
    if (method.kind === "set" && ((_params = params[params.length - 1]) == null ? void 0 : _params.type) === "RestElement") {
      this.raise(_parseError.Errors.BadSetterRestParameter, {
        at: method
      });
    }
  }
  parseObjectMethod(prop, isGenerator, isAsync, isPattern, isAccessor) {
    if (isAccessor) {
      const finishedProp = this.parseMethod(prop, isGenerator, false, false, false, "ObjectMethod");
      this.checkGetterSetterParams(finishedProp);
      return finishedProp;
    }
    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, startLoc, isPattern, refExpressionErrors) {
    prop.shorthand = false;
    if (this.eat(14)) {
      prop.value = isPattern ? this.parseMaybeDefault(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(startLoc, (0, _node.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(_parseError.Errors.InvalidCoverInitializedName, {
            at: shorthandAssignLoc
          });
        }
        prop.value = this.parseMaybeDefault(startLoc, (0, _node.cloneIdentifier)(prop.key));
      } else {
        prop.value = (0, _node.cloneIdentifier)(prop.key);
      }
      prop.shorthand = true;
      return this.finishNode(prop, "ObjectProperty");
    }
  }
  parseObjPropValue(prop, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors) {
    const node = this.parseObjectMethod(prop, isGenerator, isAsync, isPattern, isAccessor) || this.parseObjectProperty(prop, 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 ((0, _types.tokenIsKeywordOrIdentifier)(type)) {
        key = this.parseIdentifier(true);
      } else {
        switch (type) {
          case 132:
            key = this.parseNumericLiteral(value);
            break;
          case 131:
            key = this.parseStringLiteral(value);
            break;
          case 133:
            key = this.parseBigIntLiteral(value);
            break;
          case 134:
            key = this.parseDecimalLiteral(value);
            break;
          case 136:
            {
              const privateKeyLoc = this.state.startLoc;
              if (refExpressionErrors != null) {
                if (refExpressionErrors.privateKeyLoc === null) {
                  refExpressionErrors.privateKeyLoc = privateKeyLoc;
                }
              } else {
                this.raise(_parseError.Errors.UnexpectedPrivateField, {
                  at: privateKeyLoc
                });
              }
              key = this.parsePrivateName();
              break;
            }
          default:
            this.unexpected();
        }
      }
      prop.key = key;
      if (type !== 136) {
        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;
    this.scope.enter(_scopeflags.SCOPE_FUNCTION | _scopeflags.SCOPE_SUPER | (inClassScope ? _scopeflags.SCOPE_CLASS : 0) | (allowDirectSuper ? _scopeflags.SCOPE_DIRECT_SUPER : 0));
    this.prodParam.enter((0, _productionParameter.functionFlags)(isAsync, node.generator));
    this.parseFunctionParams(node, isConstructor);
    const finishedNode = this.parseFunctionBodyAndFinish(node, type, true);
    this.prodParam.exit();
    this.scope.exit();
    return finishedNode;
  }
  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(_scopeflags.SCOPE_FUNCTION | _scopeflags.SCOPE_ARROW);
    let flags = (0, _productionParameter.functionFlags)(isAsync, false);
    if (!this.match(5) && this.prodParam.hasIn) {
      flags |= _productionParameter.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) {
    this.toAssignableList(params, trailingCommaLoc, false);
    node.params = params;
  }
  parseFunctionBodyAndFinish(node, type, isMethod = false) {
    this.parseFunctionBody(node, false, isMethod);
    return this.finishNode(node, type);
  }
  parseFunctionBody(node, allowExpression, isMethod = false) {
    const isExpression = allowExpression && !this.match(5);
    this.expressionScope.enter((0, _expressionScope.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() | _productionParameter.PARAM_RETURN);
      node.body = this.parseBlock(true, false, hasStrictModeDirective => {
        const nonSimple = !this.isSimpleParamList(node.params);
        if (hasStrictModeDirective && nonSimple) {
          this.raise(_parseError.Errors.IllegalLanguageModeDirective, {
            at: (node.kind === "method" || node.kind === "constructor") && !!node.key ? node.key.loc.end : node
          });
        }
        const strictModeChanged = !oldStrict && this.state.strict;
        this.checkParams(node, !this.state.strict && !allowExpression && !isMethod && !nonSimple, allowExpression, strictModeChanged);
        if (this.state.strict && node.id) {
          this.checkIdentifier(node.id, _scopeflags.BIND_OUTSIDE, strictModeChanged);
        }
      });
      this.prodParam.exit();
      this.state.labels = oldLabels;
    }
    this.expressionScope.exit();
  }
  isSimpleParameter(node) {
    return node.type === "Identifier";
  }
  isSimpleParamList(params) {
    for (let i = 0, len = params.length; i < len; i++) {
      if (!this.isSimpleParameter(params[i])) return false;
    }
    return true;
  }
  checkParams(node, allowDuplicates, isArrowFunction, strictModeChanged = true) {
    const checkClashes = !allowDuplicates && new Set();
    const formalParameters = {
      type: "FormalParameters"
    };
    for (const param of node.params) {
      this.checkLVal(param, {
        in: formalParameters,
        binding: _scopeflags.BIND_VAR,
        checkClashes,
        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(_parseError.Errors.UnexpectedToken, {
          at: this.state.curPosition(),
          unexpected: ","
        });
      }
      elt = null;
    } else if (this.match(21)) {
      const spreadNodeStartLoc = this.state.startLoc;
      elt = this.parseParenItem(this.parseSpread(refExpressionErrors), spreadNodeStartLoc);
    } else if (this.match(17)) {
      this.expectPlugin("partialApplication");
      if (!allowPlaceholder) {
        this.raise(_parseError.Errors.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(liberal);
    return this.createIdentifier(node, name);
  }
  createIdentifier(node, name) {
    node.name = name;
    node.loc.identifierName = name;
    return this.finishNode(node, "Identifier");
  }
  parseIdentifierName(liberal) {
    let name;
    const {
      startLoc,
      type
    } = this.state;
    if ((0, _types.tokenIsKeywordOrIdentifier)(type)) {
      name = this.state.value;
    } else {
      this.unexpected();
    }
    const tokenIsKeyword = (0, _types.tokenKeywordOrIdentifierIsKeyword)(type);
    if (liberal) {
      if (tokenIsKeyword) {
        this.replaceToken(130);
      }
    } else {
      this.checkReservedWord(name, startLoc, tokenIsKeyword, false);
    }
    this.next();
    return name;
  }
  checkReservedWord(word, startLoc, checkKeywords, isBinding) {
    if (word.length > 10) {
      return;
    }
    if (!(0, _identifier.canBeReservedWord)(word)) {
      return;
    }
    if (checkKeywords && (0, _identifier.isKeyword)(word)) {
      this.raise(_parseError.Errors.UnexpectedKeyword, {
        at: startLoc,
        keyword: word
      });
      return;
    }
    const reservedTest = !this.state.strict ? _identifier.isReservedWord : isBinding ? _identifier.isStrictBindReservedWord : _identifier.isStrictReservedWord;
    if (reservedTest(word, this.inModule)) {
      this.raise(_parseError.Errors.UnexpectedReservedWord, {
        at: startLoc,
        reservedWord: word
      });
      return;
    } else if (word === "yield") {
      if (this.prodParam.hasYield) {
        this.raise(_parseError.Errors.YieldBindingIdentifier, {
          at: startLoc
        });
        return;
      }
    } else if (word === "await") {
      if (this.prodParam.hasAwait) {
        this.raise(_parseError.Errors.AwaitBindingIdentifier, {
          at: startLoc
        });
        return;
      }
      if (this.scope.inStaticBlock) {
        this.raise(_parseError.Errors.AwaitBindingIdentifierInStaticBlock, {
          at: startLoc
        });
        return;
      }
      this.expressionScope.recordAsyncArrowParametersError({
        at: startLoc
      });
    } else if (word === "arguments") {
      if (this.scope.inClassAndNotInNonArrowFunction) {
        this.raise(_parseError.Errors.ArgumentsInClass, {
          at: startLoc
        });
        return;
      }
    }
  }
  isAwaitAllowed() {
    if (this.prodParam.hasAwait) return true;
    if (this.options.allowAwaitOutsideFunction && !this.scope.inFunction) {
      return true;
    }
    return false;
  }
  parseAwait(startLoc) {
    const node = this.startNodeAt(startLoc);
    this.expressionScope.recordParameterInitializerError(_parseError.Errors.AwaitExpressionFormalParameter, {
      at: node
    });
    if (this.eat(55)) {
      this.raise(_parseError.Errors.ObsoleteAwaitStar, {
        at: 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 || (0, _types.tokenIsTemplate)(type) || type === 101 && !this.state.containsEsc || type === 135 || type === 56 || this.hasPlugin("v8intrinsic") && type === 54;
  }
  parseYield() {
    const node = this.startNode();
    this.expressionScope.recordParameterInitializerError(_parseError.Errors.YieldInParameter, {
      at: node
    });
    this.next();
    let delegating = false;
    let argument = null;
    if (!this.hasPrecedingLineBreak()) {
      delegating = this.eat(55);
      switch (this.state.type) {
        case 13:
        case 137:
        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(_parseError.Errors.PipelineHeadSequenceExpression, {
          at: leftStartLoc
        });
      }
    }
  }
  parseSmartPipelineBodyInStyle(childExpr, startLoc) {
    if (this.isSimpleReference(childExpr)) {
      const bodyNode = this.startNodeAt(startLoc);
      bodyNode.callee = childExpr;
      return this.finishNode(bodyNode, "PipelineBareFunction");
    } else {
      const bodyNode = this.startNodeAt(startLoc);
      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(_parseError.Errors.PipelineBodyNoArrow, {
        at: this.state.startLoc
      });
    }
    if (!this.topicReferenceWasUsedInCurrentContext()) {
      this.raise(_parseError.Errors.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 = _productionParameter.PARAM_IN & ~flags;
    if (prodParamToSet) {
      this.prodParam.enter(flags | _productionParameter.PARAM_IN);
      try {
        return callback();
      } finally {
        this.prodParam.exit();
      }
    }
    return callback();
  }
  disallowInAnd(callback) {
    const flags = this.prodParam.currentFlags();
    const prodParamToClear = _productionParameter.PARAM_IN & flags;
    if (prodParamToClear) {
      this.prodParam.enter(flags & ~_productionParameter.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 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(), startLoc, prec);
    this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;
    return ret;
  }
  parseModuleExpression() {
    this.expectPlugin("moduleBlocks");
    const node = this.startNode();
    this.next();
    if (!this.match(5)) {
      this.unexpected(null, 5);
    }
    const program = this.startNodeAt(this.state.endLoc);
    this.next();
    const revertScopes = this.initializeScopes(true);
    this.enterInitialScopes();
    try {
      node.body = this.parseProgram(program, 8, "module");
    } finally {
      revertScopes();
    }
    return this.finishNode(node, "ModuleExpression");
  }
  parsePropertyNamePrefixOperator(prop) {}
}
exports.default = ExpressionParser;

//# sourceMappingURL=expression.js.map
�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������lib/parser/expression.js.map������������������������������������������������������������������������0000644�����������������00000531646�15120211212�0012121 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������{"version":3,"names":["_types","require","_lval","_identifier","_location","_scopeflags","_util","_productionParameter","_expressionScope","_parseError","_pipelineOperatorErrors","_comments","_node","ExpressionParser","LValParser","checkProto","prop","isRecord","protoRef","refExpressionErrors","type","isObjectMethod","computed","shorthand","key","name","value","raise","Errors","RecordNoProto","at","used","doubleProtoLoc","loc","start","DuplicateProto","shouldExitDescending","expr","potentialArrowAt","getExpression","enterInitialScopes","nextToken","parseExpression","match","unexpected","finalizeRemainingComments","comments","state","errors","options","tokens","disallowIn","disallowInAnd","parseExpressionBase","allowInAnd","startLoc","parseMaybeAssign","node","startNodeAt","expressions","eat","push","toReferencedList","finishNode","parseMaybeAssignDisallowIn","afterLeftParse","parseMaybeAssignAllowIn","setOptionalParametersError","resultError","_resultError$loc","optionalParametersLoc","isContextual","prodParam","hasYield","left","parseYield","call","ownExpressionErrors","ExpressionErrors","tokenIsIdentifier","parseMaybeConditional","tokenIsAssignment","operator","toAssignable","startIndex","index","shorthandAssignLoc","privateKeyLoc","checkDestructuringPrivate","next","right","checkLVal","in","checkExpressionErrors","parseExprOps","parseConditional","test","consequent","expect","alternate","parseMaybeUnaryOrPrivate","parsePrivateName","parseMaybeUnary","parseExprOp","leftStartLoc","minPrec","isPrivateName","getPrivateNameSV","tokenOperatorPrecedence","hasIn","PrivateInExpectedIn","identifierName","classScope","usePrivateName","op","tokenIsOperator","prec","expectPlugin","inFSharpPipelineDirectBody","checkPipelineAtInfixOperator","logical","coalesce","hasPlugin","proposal","hasAwait","UnexpectedAwaitAfterPipelineBody","parseExprOpRightExpr","finishedNode","nextOp","MixingCoalesceWithLogical","getPluginOption","withTopicBindingContext","parseHackPipeBody","PipeBodyIsTighter","parseSmartPipelineBodyInStyle","parseExprOpBaseRightExpr","withSoloAwaitPermittingContext","parseFSharpPipelineBody","tokenIsRightAssociative","_body$extra","body","requiredParentheses","UnparenthesizedPipeBodyDescriptions","has","extra","parenthesized","PipeUnparenthesizedBody","topicReferenceWasUsedInCurrentContext","PipeTopicUnused","checkExponentialAfterUnary","UnexpectedTokenUnaryExponentiation","argument","sawUnary","isAwait","isAwaitAllowed","parseAwait","update","startNode","tokenIsPrefix","prefix","isDelete","strict","arg","StrictDelete","hasPropertyAsPrivateName","DeletePrivateField","parseUpdate","startsExpr","tokenCanStartExpression","isAmbiguousAwait","raiseOverwrite","AwaitNotInAsyncContext","updateExpressionNode","parseExprSubscripts","tokenIsPostfix","canInsertSemicolon","parseExprAtom","parseSubscripts","base","noCalls","optionalChainMember","maybeAsyncArrow","atPossibleAsyncArrow","stop","parseSubscript","parseBind","tokenIsTemplate","parseTaggedTemplateExpression","optional","OptionalChainingNoNew","lookaheadCharCode","parseCoverCallAndAsyncArrowHead","parseMember","object","property","SuperPrivateField","parseIdentifier","callee","parseNoCallExpr","oldMaybeInArrowParameters","maybeInArrowParameters","expressionScope","enter","newAsyncArrowScope","arguments","parseCallExpressionArguments","finishCallExpression","shouldParseAsyncArrow","validateAsPattern","exit","parseAsyncArrowFromCallExpression","toReferencedArguments","isParenthesizedExpr","toReferencedListDeep","tag","quasi","parseTemplate","OptionalChainingNoTemplate","lastTokEndLoc","end","expectImportAttributesPlugin","length","ImportCallArity","maxArgumentCount","ImportCallSpreadArgument","close","dynamicImport","allowPlaceholder","nodeForExtra","elts","first","oldInFSharpPipelineDirectBody","ImportCallArgumentTrailingComma","lastTokStartLoc","addTrailingCommaExtraToNode","parseExprListItem","_call$extra","resetPreviousNodeTrailingComments","parseArrowExpression","trailingCommaLoc","innerComments","setInnerComments","trailingComments","decorators","parseSuper","parseImportMetaProperty","UnsupportedImport","parseDo","readRegexp","parseRegExpLiteral","parseNumericLiteral","parseBigIntLiteral","parseDecimalLiteral","parseStringLiteral","parseNullLiteral","parseBooleanLiteral","canBeArrow","parseParenAndDistinguishExpression","parseArrayLike","parseObjectLike","parseFunctionOrFunctionSent","parseDecorators","parseClass","maybeTakeDecorators","parseNewOrNewTarget","UnsupportedBind","parseTopicReferenceThenEqualsSign","parseTopicReference","pipeProposal","lookaheadCh","input","codePointAt","nextTokenStart","isIdentifierStart","expectOnePlugin","lookaheadInLineCharCode","parseModuleExpression","containsEsc","id","parseAsyncFunctionExpression","startNodeAtNode","parseAsyncArrowUnaryFunction","topicTokenType","topicTokenValue","pos","endLoc","createPositionWithColumnOffset","tokenType","finishTopicReference","testTopicReferenceConfiguration","nodeType","topicReferenceIsAllowedInCurrentContext","PrimaryTopicNotAllowed","PipeTopicUnbound","registerTopicReference","PipeTopicUnconfiguredToken","token","tokenLabelName","topicToken","PipeTopicRequiresHackPipes","functionFlags","params","hasPrecedingLineBreak","LineTerminatorBeforeArrow","curPosition","isAsync","async","oldLabels","labels","PARAM_AWAIT","parseBlock","scope","allowDirectSuper","allowSuperOutsideMethod","SuperNotAllowed","allowSuper","UnexpectedSuper","UnsupportedSuper","createIdentifier","meta","parseMetaProperty","parseFunction","propertyName","UnsupportedMetaProperty","target","onlyValidPropertyName","inModule","ImportMetaOutsideModule","sawUnambiguousESM","parseLiteralAtNode","addExtra","slice","parseLiteral","pattern","flags","val","newArrowHeadScope","innerStartLoc","exprList","spreadStartLoc","optionalCommaStartLoc","spreadNodeStartLoc","parseParenItem","parseRestBinding","checkCommaAfterRest","innerEndLoc","arrowNode","shouldParseArrow","parseArrow","resetEndLocation","wrapParenthesis","expression","createParenthesizedExpressions","takeSurroundingComments","parenExpression","metaProp","inNonArrowFunction","inClass","allowNewTargetOutsideFunction","UnexpectedNewTarget","parseNew","parseNewCallee","args","parseExprList","ImportCallNotNewExpression","parseTemplateElement","isTagged","elemStart","elem","InvalidEscapeSequenceTemplate","firstInvalidTemplateEscapePos","isTail","endOffset","elemEnd","raw","replace","cooked","tail","curElt","quasis","parseTemplateSubstitution","readTemplateContinuation","isPattern","propHash","Object","create","properties","parseBindingProperty","parsePropertyDefinition","isObjectProperty","InvalidRecordProperty","lastTokStart","maybeAsyncOrAccessorProp","isLiteralPropertyName","UnsupportedPropertyDecorator","parseDecorator","isAccessor","parseSpread","method","isGenerator","parsePropertyNamePrefixOperator","parsePropertyName","keyName","kind","AccessorIsGenerator","parseObjPropValue","getGetterSetterExpectedParamCount","getObjectOrClassMethodParams","checkGetterSetterParams","_params","paramCount","BadGetterArity","BadSetterArity","BadSetterRestParameter","parseObjectMethod","finishedProp","parseMethod","parseObjectProperty","parseMaybeDefault","checkReservedWord","cloneIdentifier","InvalidCoverInitializedName","tokenIsKeywordOrIdentifier","UnexpectedPrivateField","initFunction","generator","isConstructor","inClassScope","SCOPE_FUNCTION","SCOPE_SUPER","SCOPE_CLASS","SCOPE_DIRECT_SUPER","parseFunctionParams","parseFunctionBodyAndFinish","canBePattern","isTuple","elements","SCOPE_ARROW","PARAM_IN","setArrowFunctionParameters","parseFunctionBody","toAssignableList","isMethod","allowExpression","isExpression","newExpressionScope","checkParams","oldStrict","currentFlags","PARAM_RETURN","hasStrictModeDirective","nonSimple","isSimpleParamList","IllegalLanguageModeDirective","strictModeChanged","checkIdentifier","BIND_OUTSIDE","isSimpleParameter","i","len","allowDuplicates","isArrowFunction","checkClashes","Set","formalParameters","param","binding","BIND_VAR","allowEmpty","elt","UnexpectedToken","UnexpectedArgumentPlaceholder","liberal","parseIdentifierName","tokenIsKeyword","tokenKeywordOrIdentifierIsKeyword","replaceToken","word","checkKeywords","isBinding","canBeReservedWord","isKeyword","UnexpectedKeyword","keyword","reservedTest","isReservedWord","isStrictBindReservedWord","isStrictReservedWord","UnexpectedReservedWord","reservedWord","YieldBindingIdentifier","AwaitBindingIdentifier","inStaticBlock","AwaitBindingIdentifierInStaticBlock","recordAsyncArrowParametersError","inClassAndNotInNonArrowFunction","ArgumentsInClass","allowAwaitOutsideFunction","inFunction","recordParameterInitializerError","AwaitExpressionFormalParameter","ObsoleteAwaitStar","ambiguousScriptDifferentAst","soloAwait","YieldInParameter","delegating","delegate","PipelineHeadSequenceExpression","childExpr","isSimpleReference","bodyNode","checkSmartPipeTopicBodyEarlyErrors","PipelineBodyNoArrow","PipelineTopicUnused","callback","outerContextTopicState","topicContext","maxNumOfResolvableTopics","maxTopicIndex","withSmartMixTopicForbiddingContext","outerContextSoloAwaitState","prodParamToSet","prodParamToClear","ret","program","revertScopes","initializeScopes","parseProgram","exports","default"],"sources":["../../src/parser/expression.ts"],"sourcesContent":["// A recursive descent parser operates by defining functions for all\n// syntactic elements, and recursively calling those, each function\n// advancing the input stream and returning an AST node. Precedence\n// of constructs (for example, the fact that `!x[1]` means `!(x[1])`\n// instead of `(!x)[1]` is handled by the fact that the parser\n// function that parses unary prefix operators is called first, and\n// in turn calls the function that parses `[]` subscripts — that\n// way, it'll receive the node for `x[1]` already parsed, and wraps\n// *that* in the unary operator node.\n//\n// Acorn uses an [operator precedence parser][opp] to handle binary\n// operator precedence, because it is much more compact than using\n// the technique outlined above, which uses different, nesting\n// functions to specify precedence, for all of the ten binary\n// precedence levels that JavaScript defines.\n//\n// [opp]: http://en.wikipedia.org/wiki/Operator-precedence_parser\n\nimport {\n  tokenCanStartExpression,\n  tokenIsAssignment,\n  tokenIsIdentifier,\n  tokenIsKeywordOrIdentifier,\n  tokenIsOperator,\n  tokenIsPostfix,\n  tokenIsPrefix,\n  tokenIsRightAssociative,\n  tokenIsTemplate,\n  tokenKeywordOrIdentifierIsKeyword,\n  tokenLabelName,\n  tokenOperatorPrecedence,\n  tt,\n  type TokenType,\n} from \"../tokenizer/types\";\nimport type * as N from \"../types\";\nimport LValParser from \"./lval\";\nimport {\n  isKeyword,\n  isReservedWord,\n  isStrictReservedWord,\n  isStrictBindReservedWord,\n  isIdentifierStart,\n  canBeReservedWord,\n} from \"../util/identifier\";\nimport {\n  type Position,\n  createPositionWithColumnOffset,\n} from \"../util/location\";\nimport * as charCodes from \"charcodes\";\nimport {\n  BIND_OUTSIDE,\n  BIND_VAR,\n  SCOPE_ARROW,\n  SCOPE_CLASS,\n  SCOPE_DIRECT_SUPER,\n  SCOPE_FUNCTION,\n  SCOPE_SUPER,\n} from \"../util/scopeflags\";\nimport { ExpressionErrors } from \"./util\";\nimport {\n  PARAM_AWAIT,\n  PARAM_IN,\n  PARAM_RETURN,\n  functionFlags,\n} from \"../util/production-parameter\";\nimport {\n  newArrowHeadScope,\n  newAsyncArrowScope,\n  newExpressionScope,\n} from \"../util/expression-scope\";\nimport { Errors, type ParseError } from \"../parse-error\";\nimport { UnparenthesizedPipeBodyDescriptions } from \"../parse-error/pipeline-operator-errors\";\nimport { setInnerComments } from \"./comments\";\nimport { cloneIdentifier, type Undone } from \"./node\";\nimport type Parser from \".\";\n\nimport type { SourceType } from \"../options\";\n\nexport default abstract class ExpressionParser extends LValParser {\n  // Forward-declaration: defined in statement.js\n  abstract parseBlock(\n    allowDirectives?: boolean,\n    createNewLexicalScope?: boolean,\n    afterBlockParse?: (hasStrictModeDirective: boolean) => void,\n  ): N.BlockStatement;\n  abstract parseClass(\n    node: N.Class,\n    isStatement: boolean,\n    optionalId?: boolean,\n  ): N.Class;\n  abstract parseDecorators(allowExport?: boolean): void;\n  abstract parseFunction<T extends N.NormalFunction>(\n    node: T,\n    statement?: number,\n    allowExpressionBody?: boolean,\n    isAsync?: boolean,\n  ): T;\n  abstract parseFunctionParams(node: N.Function, isConstructor?: boolean): void;\n  abstract parseBlockOrModuleBlockBody(\n    body: N.Statement[],\n    directives: N.Directive[] | null | undefined,\n    topLevel: boolean,\n    end: TokenType,\n    afterBlockParse?: (hasStrictModeDirective: boolean) => void,\n  ): void;\n  abstract parseProgram(\n    program: N.Program,\n    end: TokenType,\n    sourceType?: SourceType,\n  ): N.Program;\n\n  // For object literal, check if property __proto__ has been used more than once.\n  // If the expression is a destructuring assignment, then __proto__ may appear\n  // multiple times. Otherwise, __proto__ is a duplicated key.\n\n  // For record expression, check if property __proto__ exists\n\n  checkProto(\n    prop: N.ObjectMember | N.SpreadElement,\n    isRecord: boolean | undefined | null,\n    protoRef: {\n      used: boolean;\n    },\n    refExpressionErrors?: ExpressionErrors | null,\n  ): void {\n    if (\n      prop.type === \"SpreadElement\" ||\n      this.isObjectMethod(prop) ||\n      prop.computed ||\n      // @ts-expect-error prop must be an ObjectProperty\n      prop.shorthand\n    ) {\n      return;\n    }\n\n    const key = prop.key;\n    // It is either an Identifier or a String/NumericLiteral\n    const name = key.type === \"Identifier\" ? key.name : key.value;\n\n    if (name === \"__proto__\") {\n      if (isRecord) {\n        this.raise(Errors.RecordNoProto, { at: key });\n        return;\n      }\n      if (protoRef.used) {\n        if (refExpressionErrors) {\n          // Store the first redefinition's position, otherwise ignore because\n          // we are parsing ambiguous pattern\n          if (refExpressionErrors.doubleProtoLoc === null) {\n            refExpressionErrors.doubleProtoLoc = key.loc.start;\n          }\n        } else {\n          this.raise(Errors.DuplicateProto, { at: key });\n        }\n      }\n\n      protoRef.used = true;\n    }\n  }\n\n  shouldExitDescending(expr: N.Expression, potentialArrowAt: number): boolean {\n    return (\n      expr.type === \"ArrowFunctionExpression\" && expr.start === potentialArrowAt\n    );\n  }\n\n  // Convenience method to parse an Expression only\n  getExpression(this: Parser): N.Expression & N.ParserOutput {\n    this.enterInitialScopes();\n    this.nextToken();\n    const expr = this.parseExpression();\n    if (!this.match(tt.eof)) {\n      this.unexpected();\n    }\n    // Unlike parseTopLevel, we need to drain remaining commentStacks\n    // because the top level node is _not_ Program.\n    this.finalizeRemainingComments();\n    expr.comments = this.state.comments;\n    expr.errors = this.state.errors;\n    if (this.options.tokens) {\n      expr.tokens = this.tokens;\n    }\n    // @ts-expect-error fixme: refine types\n    return expr;\n  }\n\n  // ### Expression parsing\n\n  // These nest, from the most general expression type at the top to\n  // 'atomic', nondivisible expression types at the bottom. Most of\n  // the functions will simply let the function (s) below them parse,\n  // and, *if* the syntactic construct they handle is present, wrap\n  // the AST node that the inner parser gave them in another node.\n\n  // Parse a full expression.\n  // - `disallowIn`\n  //   is used to forbid the `in` operator (in for loops initialization expressions)\n  //   When `disallowIn` is true, the production parameter [In] is not present.\n\n  // - `refExpressionErrors `\n  //   provides reference for storing '=' operator inside shorthand\n  //   property assignment in contexts where both object expression\n  //   and object pattern might appear (so it's possible to raise\n  //   delayed syntax error at correct position).\n\n  parseExpression(\n    this: Parser,\n    disallowIn?: boolean,\n    refExpressionErrors?: ExpressionErrors,\n  ): N.Expression {\n    if (disallowIn) {\n      return this.disallowInAnd(() =>\n        this.parseExpressionBase(refExpressionErrors),\n      );\n    }\n    return this.allowInAnd(() => this.parseExpressionBase(refExpressionErrors));\n  }\n\n  // https://tc39.es/ecma262/#prod-Expression\n  parseExpressionBase(\n    this: Parser,\n    refExpressionErrors?: ExpressionErrors,\n  ): N.Expression {\n    const startLoc = this.state.startLoc;\n    const expr = this.parseMaybeAssign(refExpressionErrors);\n    if (this.match(tt.comma)) {\n      const node = this.startNodeAt(startLoc);\n      node.expressions = [expr];\n      while (this.eat(tt.comma)) {\n        node.expressions.push(this.parseMaybeAssign(refExpressionErrors));\n      }\n      this.toReferencedList(node.expressions);\n      return this.finishNode(node, \"SequenceExpression\");\n    }\n    return expr;\n  }\n\n  // Set [~In] parameter for assignment expression\n  parseMaybeAssignDisallowIn(\n    this: Parser,\n    refExpressionErrors?: ExpressionErrors | null,\n    afterLeftParse?: Function,\n  ) {\n    return this.disallowInAnd(() =>\n      this.parseMaybeAssign(refExpressionErrors, afterLeftParse),\n    );\n  }\n\n  // Set [+In] parameter for assignment expression\n  parseMaybeAssignAllowIn(\n    this: Parser,\n    refExpressionErrors?: ExpressionErrors | null,\n    afterLeftParse?: Function,\n  ) {\n    return this.allowInAnd(() =>\n      this.parseMaybeAssign(refExpressionErrors, afterLeftParse),\n    );\n  }\n\n  // This method is only used by\n  // the typescript and flow plugins.\n  setOptionalParametersError(\n    refExpressionErrors: ExpressionErrors,\n    resultError?: ParseError<any>,\n  ) {\n    refExpressionErrors.optionalParametersLoc =\n      resultError?.loc ?? this.state.startLoc;\n  }\n\n  // Parse an assignment expression. This includes applications of\n  // operators like `+=`.\n  // https://tc39.es/ecma262/#prod-AssignmentExpression\n  parseMaybeAssign(\n    this: Parser,\n    refExpressionErrors?: ExpressionErrors | null,\n    afterLeftParse?: Function,\n  ): N.Expression {\n    const startLoc = this.state.startLoc;\n    if (this.isContextual(tt._yield)) {\n      if (this.prodParam.hasYield) {\n        let left = this.parseYield();\n        if (afterLeftParse) {\n          left = afterLeftParse.call(this, left, startLoc);\n        }\n        return left;\n      }\n    }\n\n    let ownExpressionErrors;\n    if (refExpressionErrors) {\n      ownExpressionErrors = false;\n    } else {\n      refExpressionErrors = new ExpressionErrors();\n      ownExpressionErrors = true;\n    }\n    const { type } = this.state;\n\n    if (type === tt.parenL || tokenIsIdentifier(type)) {\n      this.state.potentialArrowAt = this.state.start;\n    }\n\n    let left = this.parseMaybeConditional(refExpressionErrors);\n    if (afterLeftParse) {\n      left = afterLeftParse.call(this, left, startLoc);\n    }\n    if (tokenIsAssignment(this.state.type)) {\n      const node = this.startNodeAt<N.AssignmentExpression>(startLoc);\n      const operator = this.state.value;\n      node.operator = operator;\n\n      if (this.match(tt.eq)) {\n        this.toAssignable(left, /* isLHS */ true);\n        node.left = left;\n\n        const startIndex = startLoc.index;\n        if (\n          refExpressionErrors.doubleProtoLoc != null &&\n          refExpressionErrors.doubleProtoLoc.index >= startIndex\n        ) {\n          refExpressionErrors.doubleProtoLoc = null; // reset because double __proto__ is valid in assignment expression\n        }\n        if (\n          refExpressionErrors.shorthandAssignLoc != null &&\n          refExpressionErrors.shorthandAssignLoc.index >= startIndex\n        ) {\n          refExpressionErrors.shorthandAssignLoc = null; // reset because shorthand default was used correctly\n        }\n        if (\n          refExpressionErrors.privateKeyLoc != null &&\n          refExpressionErrors.privateKeyLoc.index >= startIndex\n        ) {\n          this.checkDestructuringPrivate(refExpressionErrors);\n          refExpressionErrors.privateKeyLoc = null; // reset because `({ #x: x })` is an assignable pattern\n        }\n      } else {\n        node.left = left;\n      }\n\n      this.next();\n      node.right = this.parseMaybeAssign();\n      this.checkLVal(left, {\n        in: this.finishNode(node, \"AssignmentExpression\"),\n      });\n      // @ts-expect-error todo(flow->ts) improve node types\n      return node;\n    } else if (ownExpressionErrors) {\n      this.checkExpressionErrors(refExpressionErrors, true);\n    }\n\n    return left;\n  }\n\n  // Parse a ternary conditional (`?:`) operator.\n  // https://tc39.es/ecma262/#prod-ConditionalExpression\n\n  parseMaybeConditional(\n    this: Parser,\n    refExpressionErrors: ExpressionErrors,\n  ): N.Expression {\n    const startLoc = this.state.startLoc;\n    const potentialArrowAt = this.state.potentialArrowAt;\n    const expr = this.parseExprOps(refExpressionErrors);\n\n    if (this.shouldExitDescending(expr, potentialArrowAt)) {\n      return expr;\n    }\n\n    return this.parseConditional(expr, startLoc, refExpressionErrors);\n  }\n\n  parseConditional(\n    this: Parser,\n    expr: N.Expression,\n    startLoc: Position,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    refExpressionErrors?: ExpressionErrors | null,\n  ): N.Expression {\n    if (this.eat(tt.question)) {\n      const node = this.startNodeAt(startLoc);\n      node.test = expr;\n      node.consequent = this.parseMaybeAssignAllowIn();\n      this.expect(tt.colon);\n      node.alternate = this.parseMaybeAssign();\n      return this.finishNode(node, \"ConditionalExpression\");\n    }\n    return expr;\n  }\n\n  parseMaybeUnaryOrPrivate(\n    this: Parser,\n    refExpressionErrors?: ExpressionErrors,\n  ): N.Expression | N.PrivateName {\n    return this.match(tt.privateName)\n      ? this.parsePrivateName()\n      : this.parseMaybeUnary(refExpressionErrors);\n  }\n\n  // Start the precedence parser.\n  // https://tc39.es/ecma262/#prod-ShortCircuitExpression\n\n  parseExprOps(\n    this: Parser,\n    refExpressionErrors: ExpressionErrors,\n  ): N.Expression {\n    const startLoc = this.state.startLoc;\n    const potentialArrowAt = this.state.potentialArrowAt;\n    const expr = this.parseMaybeUnaryOrPrivate(refExpressionErrors);\n\n    if (this.shouldExitDescending(expr, potentialArrowAt)) {\n      return expr;\n    }\n\n    return this.parseExprOp(expr, startLoc, -1);\n  }\n\n  // Parse binary operators with the operator precedence parsing\n  // algorithm. `left` is the left-hand side of the operator.\n  // `minPrec` provides context that allows the function to stop and\n  // defer further parser to one of its callers when it encounters an\n  // operator that has a lower precedence than the set it is parsing.\n\n  parseExprOp(\n    this: Parser,\n    left: N.Expression | N.PrivateName,\n    leftStartLoc: Position,\n    minPrec: number,\n  ): N.Expression {\n    if (this.isPrivateName(left)) {\n      // https://tc39.es/ecma262/#prod-RelationalExpression\n      // RelationalExpression [In, Yield, Await]\n      //   [+In] PrivateIdentifier in ShiftExpression[?Yield, ?Await]\n\n      const value = this.getPrivateNameSV(left);\n\n      if (\n        minPrec >= tokenOperatorPrecedence(tt._in) ||\n        !this.prodParam.hasIn ||\n        !this.match(tt._in)\n      ) {\n        this.raise(Errors.PrivateInExpectedIn, {\n          at: left,\n          identifierName: value,\n        });\n      }\n\n      this.classScope.usePrivateName(value, left.loc.start);\n    }\n\n    const op = this.state.type;\n    if (tokenIsOperator(op) && (this.prodParam.hasIn || !this.match(tt._in))) {\n      let prec = tokenOperatorPrecedence(op);\n      if (prec > minPrec) {\n        if (op === tt.pipeline) {\n          this.expectPlugin(\"pipelineOperator\");\n          if (this.state.inFSharpPipelineDirectBody) {\n            return left;\n          }\n          this.checkPipelineAtInfixOperator(left, leftStartLoc);\n        }\n        const node = this.startNodeAt<N.LogicalExpression | N.BinaryExpression>(\n          leftStartLoc,\n        );\n        node.left = left;\n        node.operator = this.state.value;\n\n        const logical = op === tt.logicalOR || op === tt.logicalAND;\n        const coalesce = op === tt.nullishCoalescing;\n\n        if (coalesce) {\n          // Handle the precedence of `tt.coalesce` as equal to the range of logical expressions.\n          // In other words, `node.right` shouldn't contain logical expressions in order to check the mixed error.\n          prec = tokenOperatorPrecedence(tt.logicalAND);\n        }\n\n        this.next();\n\n        if (\n          op === tt.pipeline &&\n          this.hasPlugin([\"pipelineOperator\", { proposal: \"minimal\" }])\n        ) {\n          if (this.state.type === tt._await && this.prodParam.hasAwait) {\n            throw this.raise(Errors.UnexpectedAwaitAfterPipelineBody, {\n              at: this.state.startLoc,\n            });\n          }\n        }\n\n        node.right = this.parseExprOpRightExpr(op, prec);\n        const finishedNode = this.finishNode(\n          node,\n          logical || coalesce ? \"LogicalExpression\" : \"BinaryExpression\",\n        );\n        /* this check is for all ?? operators\n         * a ?? b && c for this example\n         * when op is coalesce and nextOp is logical (&&), throw at the pos of nextOp that it can not be mixed.\n         * Symmetrically it also throws when op is logical and nextOp is coalesce\n         */\n        const nextOp = this.state.type;\n        if (\n          (coalesce && (nextOp === tt.logicalOR || nextOp === tt.logicalAND)) ||\n          (logical && nextOp === tt.nullishCoalescing)\n        ) {\n          throw this.raise(Errors.MixingCoalesceWithLogical, {\n            at: this.state.startLoc,\n          });\n        }\n\n        return this.parseExprOp(finishedNode, leftStartLoc, minPrec);\n      }\n    }\n    return left;\n  }\n\n  // Helper function for `parseExprOp`. Parse the right-hand side of binary-\n  // operator expressions, then apply any operator-specific functions.\n\n  parseExprOpRightExpr(\n    this: Parser,\n    op: TokenType,\n    prec: number,\n  ): N.Expression {\n    const startLoc = this.state.startLoc;\n    switch (op) {\n      case tt.pipeline:\n        switch (this.getPluginOption(\"pipelineOperator\", \"proposal\")) {\n          case \"hack\":\n            return this.withTopicBindingContext(() => {\n              return this.parseHackPipeBody();\n            });\n\n          case \"smart\":\n            return this.withTopicBindingContext(() => {\n              if (this.prodParam.hasYield && this.isContextual(tt._yield)) {\n                throw this.raise(Errors.PipeBodyIsTighter, {\n                  at: this.state.startLoc,\n                });\n              }\n              return this.parseSmartPipelineBodyInStyle(\n                this.parseExprOpBaseRightExpr(op, prec),\n                startLoc,\n              );\n            });\n\n          case \"fsharp\":\n            return this.withSoloAwaitPermittingContext(() => {\n              return this.parseFSharpPipelineBody(prec);\n            });\n        }\n\n      // Falls through.\n      default:\n        return this.parseExprOpBaseRightExpr(op, prec);\n    }\n  }\n\n  // Helper function for `parseExprOpRightExpr`. Parse the right-hand side of\n  // binary-operator expressions without applying any operator-specific functions.\n\n  parseExprOpBaseRightExpr(\n    this: Parser,\n    op: TokenType,\n    prec: number,\n  ): N.Expression {\n    const startLoc = this.state.startLoc;\n\n    return this.parseExprOp(\n      this.parseMaybeUnaryOrPrivate(),\n      startLoc,\n      tokenIsRightAssociative(op) ? prec - 1 : prec,\n    );\n  }\n\n  parseHackPipeBody(this: Parser): N.Expression {\n    const { startLoc } = this.state;\n    const body = this.parseMaybeAssign();\n    const requiredParentheses = UnparenthesizedPipeBodyDescriptions.has(\n      // @ts-expect-error TS2345: Argument of type 'string' is not assignable to parameter of type '\"ArrowFunctionExpression\" | \"YieldExpression\" | \"AssignmentExpression\" | \"ConditionalExpression\"'.\n      body.type,\n    );\n\n    // TODO: Check how to handle type casts in Flow and TS once they are supported\n    if (requiredParentheses && !body.extra?.parenthesized) {\n      this.raise(Errors.PipeUnparenthesizedBody, {\n        at: startLoc,\n        // @ts-expect-error TS2322: Type 'string' is not assignable to type '\"AssignmentExpression\" | \"ArrowFunctionExpression\" | \"ConditionalExpression\" | \"YieldExpression\"'.\n        type: body.type,\n      });\n    }\n    if (!this.topicReferenceWasUsedInCurrentContext()) {\n      // A Hack pipe body must use the topic reference at least once.\n      this.raise(Errors.PipeTopicUnused, { at: startLoc });\n    }\n\n    return body;\n  }\n\n  checkExponentialAfterUnary(\n    node: N.AwaitExpression | Undone<N.UnaryExpression>,\n  ) {\n    if (this.match(tt.exponent)) {\n      this.raise(Errors.UnexpectedTokenUnaryExponentiation, {\n        at: node.argument,\n      });\n    }\n  }\n\n  // Parse unary operators, both prefix and postfix.\n  // https://tc39.es/ecma262/#prod-UnaryExpression\n  parseMaybeUnary(\n    this: Parser,\n    refExpressionErrors?: ExpressionErrors | null,\n    sawUnary?: boolean,\n  ): N.Expression {\n    const startLoc = this.state.startLoc;\n    const isAwait = this.isContextual(tt._await);\n\n    if (isAwait && this.isAwaitAllowed()) {\n      this.next();\n      const expr = this.parseAwait(startLoc);\n      if (!sawUnary) this.checkExponentialAfterUnary(expr);\n      return expr;\n    }\n    const update = this.match(tt.incDec);\n    const node = this.startNode<N.UnaryExpression | N.UpdateExpression>();\n    if (tokenIsPrefix(this.state.type)) {\n      node.operator = this.state.value;\n      node.prefix = true;\n\n      if (this.match(tt._throw)) {\n        this.expectPlugin(\"throwExpressions\");\n      }\n      const isDelete = this.match(tt._delete);\n      this.next();\n\n      node.argument = this.parseMaybeUnary(null, true);\n\n      this.checkExpressionErrors(refExpressionErrors, true);\n\n      if (this.state.strict && isDelete) {\n        const arg = node.argument;\n\n        if (arg.type === \"Identifier\") {\n          this.raise(Errors.StrictDelete, { at: node });\n        } else if (this.hasPropertyAsPrivateName(arg)) {\n          this.raise(Errors.DeletePrivateField, { at: node });\n        }\n      }\n\n      if (!update) {\n        if (!sawUnary) {\n          this.checkExponentialAfterUnary(node as Undone<N.UnaryExpression>);\n        }\n        return this.finishNode(node, \"UnaryExpression\");\n      }\n    }\n\n    const expr = this.parseUpdate(\n      // @ts-expect-error using \"Undone\" node as \"done\"\n      node,\n      update,\n      refExpressionErrors,\n    );\n\n    if (isAwait) {\n      const { type } = this.state;\n      const startsExpr = this.hasPlugin(\"v8intrinsic\")\n        ? tokenCanStartExpression(type)\n        : tokenCanStartExpression(type) && !this.match(tt.modulo);\n      if (startsExpr && !this.isAmbiguousAwait()) {\n        this.raiseOverwrite(Errors.AwaitNotInAsyncContext, { at: startLoc });\n        return this.parseAwait(startLoc);\n      }\n    }\n\n    return expr;\n  }\n\n  // https://tc39.es/ecma262/#prod-UpdateExpression\n  parseUpdate(\n    this: Parser,\n    node: N.Expression,\n    update: boolean,\n    refExpressionErrors?: ExpressionErrors | null,\n  ): N.Expression {\n    if (update) {\n      // @ts-expect-error Type 'Node' is missing the following properties from type 'Undone<UpdateExpression>': prefix, operator, argument\n      const updateExpressionNode = node as Undone<N.UpdateExpression>;\n      this.checkLVal(updateExpressionNode.argument, {\n        in: this.finishNode(updateExpressionNode, \"UpdateExpression\"),\n      });\n      return node;\n    }\n\n    const startLoc = this.state.startLoc;\n    let expr = this.parseExprSubscripts(refExpressionErrors);\n    if (this.checkExpressionErrors(refExpressionErrors, false)) return expr;\n    while (tokenIsPostfix(this.state.type) && !this.canInsertSemicolon()) {\n      const node = this.startNodeAt<N.UpdateExpression>(startLoc);\n      node.operator = this.state.value;\n      node.prefix = false;\n      node.argument = expr;\n      this.next();\n      this.checkLVal(expr, {\n        in: (expr = this.finishNode(node, \"UpdateExpression\")),\n      });\n    }\n    return expr;\n  }\n\n  // Parse call, dot, and `[]`-subscript expressions.\n  // https://tc39.es/ecma262/#prod-LeftHandSideExpression\n  parseExprSubscripts(\n    this: Parser,\n    refExpressionErrors?: ExpressionErrors | null,\n  ): N.Expression {\n    const startLoc = this.state.startLoc;\n    const potentialArrowAt = this.state.potentialArrowAt;\n    const expr = this.parseExprAtom(refExpressionErrors);\n\n    if (this.shouldExitDescending(expr, potentialArrowAt)) {\n      return expr;\n    }\n\n    return this.parseSubscripts(expr, startLoc);\n  }\n\n  parseSubscripts(\n    this: Parser,\n    base: N.Expression,\n    startLoc: Position,\n    noCalls?: boolean | null,\n  ): N.Expression {\n    const state = {\n      optionalChainMember: false,\n      maybeAsyncArrow: this.atPossibleAsyncArrow(base),\n      stop: false,\n    };\n    do {\n      base = this.parseSubscript(base, startLoc, noCalls, state);\n\n      // After parsing a subscript, this isn't \"async\" for sure.\n      state.maybeAsyncArrow = false;\n    } while (!state.stop);\n    return base;\n  }\n\n  /**\n   * @param state Set 'state.stop = true' to indicate that we should stop parsing subscripts.\n   *   state.optionalChainMember to indicate that the member is currently in OptionalChain\n   */\n  parseSubscript(\n    this: Parser,\n    base: N.Expression,\n    startLoc: Position,\n    noCalls: boolean | undefined | null,\n    state: N.ParseSubscriptState,\n  ): N.Expression {\n    const { type } = this.state;\n    if (!noCalls && type === tt.doubleColon) {\n      return this.parseBind(base, startLoc, noCalls, state);\n    } else if (tokenIsTemplate(type)) {\n      return this.parseTaggedTemplateExpression(base, startLoc, state);\n    }\n\n    let optional = false;\n\n    if (type === tt.questionDot) {\n      if (noCalls) {\n        this.raise(Errors.OptionalChainingNoNew, {\n          at: this.state.startLoc,\n        });\n        if (this.lookaheadCharCode() === charCodes.leftParenthesis) {\n          // stop at `?.` when parsing `new a?.()`\n          state.stop = true;\n          return base;\n        }\n      }\n      state.optionalChainMember = optional = true;\n      this.next();\n    }\n\n    if (!noCalls && this.match(tt.parenL)) {\n      return this.parseCoverCallAndAsyncArrowHead(\n        base,\n        startLoc,\n        state,\n        optional,\n      );\n    } else {\n      const computed = this.eat(tt.bracketL);\n      if (computed || optional || this.eat(tt.dot)) {\n        return this.parseMember(base, startLoc, state, computed, optional);\n      } else {\n        state.stop = true;\n        return base;\n      }\n    }\n  }\n\n  // base[?Yield, ?Await] [ Expression[+In, ?Yield, ?Await] ]\n  // base[?Yield, ?Await] . IdentifierName\n  // base[?Yield, ?Await] . PrivateIdentifier\n  //   where `base` is one of CallExpression, MemberExpression and OptionalChain\n  parseMember(\n    this: Parser,\n    base: N.Expression,\n    startLoc: Position,\n    state: N.ParseSubscriptState,\n    computed: boolean,\n    optional: boolean,\n  ): N.OptionalMemberExpression | N.MemberExpression {\n    const node = this.startNodeAt<\n      N.OptionalMemberExpression | N.MemberExpression\n    >(startLoc);\n    node.object = base;\n    node.computed = computed;\n    if (computed) {\n      node.property = this.parseExpression();\n      this.expect(tt.bracketR);\n    } else if (this.match(tt.privateName)) {\n      if (base.type === \"Super\") {\n        this.raise(Errors.SuperPrivateField, { at: startLoc });\n      }\n      this.classScope.usePrivateName(this.state.value, this.state.startLoc);\n      node.property = this.parsePrivateName();\n    } else {\n      node.property = this.parseIdentifier(true);\n    }\n\n    if (state.optionalChainMember) {\n      (node as N.OptionalMemberExpression).optional = optional;\n      return this.finishNode(node, \"OptionalMemberExpression\");\n    } else {\n      return this.finishNode(node, \"MemberExpression\");\n    }\n  }\n\n  // https://github.com/tc39/proposal-bind-operator#syntax\n  parseBind(\n    this: Parser,\n    base: N.Expression,\n    startLoc: Position,\n    noCalls: boolean | undefined | null,\n    state: N.ParseSubscriptState,\n  ): N.Expression {\n    const node = this.startNodeAt(startLoc);\n    node.object = base;\n    this.next(); // eat '::'\n    node.callee = this.parseNoCallExpr();\n    state.stop = true;\n    return this.parseSubscripts(\n      this.finishNode(node, \"BindExpression\"),\n      startLoc,\n      noCalls,\n    );\n  }\n\n  // https://tc39.es/ecma262/#prod-CoverCallExpressionAndAsyncArrowHead\n  // CoverCallExpressionAndAsyncArrowHead\n  // CallExpression[?Yield, ?Await] Arguments[?Yield, ?Await]\n  // OptionalChain[?Yield, ?Await] Arguments[?Yield, ?Await]\n  parseCoverCallAndAsyncArrowHead(\n    this: Parser,\n    base: N.Expression,\n    startLoc: Position,\n    state: N.ParseSubscriptState,\n    optional: boolean,\n  ): N.Expression {\n    const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;\n    let refExpressionErrors: ExpressionErrors | null = null;\n\n    this.state.maybeInArrowParameters = true;\n    this.next(); // eat `(`\n\n    const node = this.startNodeAt<N.CallExpression | N.OptionalCallExpression>(\n      startLoc,\n    );\n    node.callee = base;\n    const { maybeAsyncArrow, optionalChainMember } = state;\n\n    if (maybeAsyncArrow) {\n      this.expressionScope.enter(newAsyncArrowScope());\n      refExpressionErrors = new ExpressionErrors();\n    }\n\n    if (optionalChainMember) {\n      // @ts-expect-error when optionalChainMember is true, node must be an optional call\n      node.optional = optional;\n    }\n\n    if (optional) {\n      node.arguments = this.parseCallExpressionArguments(tt.parenR);\n    } else {\n      node.arguments = this.parseCallExpressionArguments(\n        tt.parenR,\n        base.type === \"Import\",\n        base.type !== \"Super\",\n        // @ts-expect-error todo(flow->ts)\n        node,\n        refExpressionErrors,\n      );\n    }\n    let finishedNode:\n      | N.CallExpression\n      | N.OptionalCallExpression\n      | N.ArrowFunctionExpression = this.finishCallExpression(\n      node,\n      optionalChainMember,\n    );\n\n    if (maybeAsyncArrow && this.shouldParseAsyncArrow() && !optional) {\n      /*:: invariant(refExpressionErrors != null) */\n      state.stop = true;\n      this.checkDestructuringPrivate(refExpressionErrors);\n      this.expressionScope.validateAsPattern();\n      this.expressionScope.exit();\n      finishedNode = this.parseAsyncArrowFromCallExpression(\n        this.startNodeAt<N.ArrowFunctionExpression>(startLoc),\n        finishedNode as N.CallExpression,\n      );\n    } else {\n      if (maybeAsyncArrow) {\n        this.checkExpressionErrors(refExpressionErrors, true);\n        this.expressionScope.exit();\n      }\n      this.toReferencedArguments(finishedNode);\n    }\n\n    this.state.maybeInArrowParameters = oldMaybeInArrowParameters;\n\n    return finishedNode;\n  }\n\n  toReferencedArguments(\n    node: N.CallExpression | N.OptionalCallExpression,\n    isParenthesizedExpr?: boolean,\n  ) {\n    this.toReferencedListDeep(node.arguments, isParenthesizedExpr);\n  }\n\n  // MemberExpression [?Yield, ?Await] TemplateLiteral[?Yield, ?Await, +Tagged]\n  // CallExpression [?Yield, ?Await] TemplateLiteral[?Yield, ?Await, +Tagged]\n  parseTaggedTemplateExpression(\n    this: Parser,\n    base: N.Expression,\n    startLoc: Position,\n    state: N.ParseSubscriptState,\n  ): N.TaggedTemplateExpression {\n    const node = this.startNodeAt<N.TaggedTemplateExpression>(startLoc);\n    node.tag = base;\n    node.quasi = this.parseTemplate(true);\n    if (state.optionalChainMember) {\n      this.raise(Errors.OptionalChainingNoTemplate, { at: startLoc });\n    }\n    return this.finishNode(node, \"TaggedTemplateExpression\");\n  }\n\n  atPossibleAsyncArrow(base: N.Expression): boolean {\n    return (\n      base.type === \"Identifier\" &&\n      base.name === \"async\" &&\n      this.state.lastTokEndLoc.index === base.end &&\n      !this.canInsertSemicolon() &&\n      // check there are no escape sequences, such as \\u{61}sync\n      base.end - base.start === 5 &&\n      base.start === this.state.potentialArrowAt\n    );\n  }\n\n  expectImportAttributesPlugin() {\n    if (!this.hasPlugin(\"importAssertions\")) {\n      this.expectPlugin(\"importAttributes\");\n    }\n  }\n\n  finishCallExpression<T extends N.CallExpression | N.OptionalCallExpression>(\n    node: Undone<T>,\n    optional: boolean,\n  ): T {\n    if (node.callee.type === \"Import\") {\n      if (node.arguments.length === 2) {\n        if (process.env.BABEL_8_BREAKING) {\n          this.expectImportAttributesPlugin();\n        } else {\n          if (!this.hasPlugin(\"moduleAttributes\")) {\n            this.expectImportAttributesPlugin();\n          }\n        }\n      }\n      if (node.arguments.length === 0 || node.arguments.length > 2) {\n        this.raise(Errors.ImportCallArity, {\n          at: node,\n          maxArgumentCount:\n            this.hasPlugin(\"importAttributes\") ||\n            this.hasPlugin(\"importAssertions\") ||\n            this.hasPlugin(\"moduleAttributes\")\n              ? 2\n              : 1,\n        });\n      } else {\n        for (const arg of node.arguments) {\n          if (arg.type === \"SpreadElement\") {\n            this.raise(Errors.ImportCallSpreadArgument, { at: arg });\n          }\n        }\n      }\n    }\n    return this.finishNode(\n      node,\n      optional ? \"OptionalCallExpression\" : \"CallExpression\",\n    );\n  }\n\n  parseCallExpressionArguments(\n    this: Parser,\n    close: TokenType,\n    dynamicImport?: boolean,\n    allowPlaceholder?: boolean,\n    nodeForExtra?: N.Node | null,\n    refExpressionErrors?: ExpressionErrors | null,\n  ): Array<N.Expression | undefined | null> {\n    const elts: N.Expression[] = [];\n    let first = true;\n    const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;\n    this.state.inFSharpPipelineDirectBody = false;\n\n    while (!this.eat(close)) {\n      if (first) {\n        first = false;\n      } else {\n        this.expect(tt.comma);\n        if (this.match(close)) {\n          if (\n            dynamicImport &&\n            !this.hasPlugin(\"importAttributes\") &&\n            !this.hasPlugin(\"importAssertions\") &&\n            !this.hasPlugin(\"moduleAttributes\")\n          ) {\n            this.raise(Errors.ImportCallArgumentTrailingComma, {\n              at: this.state.lastTokStartLoc,\n            });\n          }\n          if (nodeForExtra) {\n            this.addTrailingCommaExtraToNode(nodeForExtra);\n          }\n          this.next();\n          break;\n        }\n      }\n\n      elts.push(\n        this.parseExprListItem(false, refExpressionErrors, allowPlaceholder),\n      );\n    }\n\n    this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;\n\n    return elts;\n  }\n\n  shouldParseAsyncArrow(): boolean {\n    return this.match(tt.arrow) && !this.canInsertSemicolon();\n  }\n\n  parseAsyncArrowFromCallExpression(\n    this: Parser,\n    node: Undone<N.ArrowFunctionExpression>,\n    call: N.CallExpression,\n  ): N.ArrowFunctionExpression {\n    this.resetPreviousNodeTrailingComments(call);\n    this.expect(tt.arrow);\n    this.parseArrowExpression(\n      node,\n      call.arguments,\n      true,\n      call.extra?.trailingCommaLoc,\n    );\n    // mark inner comments of `async()` as inner comments of `async () =>`\n    if (call.innerComments) {\n      setInnerComments(node, call.innerComments);\n    }\n    // mark trailing comments of `async` to be inner comments\n    if (call.callee.trailingComments) {\n      setInnerComments(node, call.callee.trailingComments);\n    }\n    return node as N.ArrowFunctionExpression;\n  }\n\n  // Parse a no-call expression (like argument of `new` or `::` operators).\n  // https://tc39.es/ecma262/#prod-MemberExpression\n  parseNoCallExpr(this: Parser): N.Expression {\n    const startLoc = this.state.startLoc;\n    return this.parseSubscripts(this.parseExprAtom(), startLoc, true);\n  }\n\n  // Parse an atomic expression — either a single token that is an\n  // expression, an expression started by a keyword like `function` or\n  // `new`, or an expression wrapped in punctuation like `()`, `[]`,\n  // or `{}`.\n\n  // https://tc39.es/ecma262/#prod-PrimaryExpression\n  // https://tc39.es/ecma262/#prod-AsyncArrowFunction\n  // PrimaryExpression\n  // Super\n  // Import\n  // AsyncArrowFunction\n\n  parseExprAtom(\n    this: Parser,\n    refExpressionErrors?: ExpressionErrors | null,\n  ): N.Expression {\n    let node;\n    let decorators: N.Decorator[] | null = null;\n\n    const { type } = this.state;\n    switch (type) {\n      case tt._super:\n        return this.parseSuper();\n\n      case tt._import:\n        node = this.startNode<N.MetaProperty | N.Import>();\n        this.next();\n\n        if (this.match(tt.dot)) {\n          return this.parseImportMetaProperty(node as Undone<N.MetaProperty>);\n        }\n\n        if (!this.match(tt.parenL)) {\n          this.raise(Errors.UnsupportedImport, {\n            at: this.state.lastTokStartLoc,\n          });\n        }\n        return this.finishNode(node, \"Import\");\n      case tt._this:\n        node = this.startNode();\n        this.next();\n        return this.finishNode(node, \"ThisExpression\");\n\n      case tt._do: {\n        return this.parseDo(this.startNode(), false);\n      }\n\n      case tt.slash:\n      case tt.slashAssign: {\n        this.readRegexp();\n        return this.parseRegExpLiteral(this.state.value);\n      }\n\n      case tt.num:\n        return this.parseNumericLiteral(this.state.value);\n\n      case tt.bigint:\n        return this.parseBigIntLiteral(this.state.value);\n\n      case tt.decimal:\n        return this.parseDecimalLiteral(this.state.value);\n\n      case tt.string:\n        return this.parseStringLiteral(this.state.value);\n\n      case tt._null:\n        return this.parseNullLiteral();\n\n      case tt._true:\n        return this.parseBooleanLiteral(true);\n      case tt._false:\n        return this.parseBooleanLiteral(false);\n\n      case tt.parenL: {\n        const canBeArrow = this.state.potentialArrowAt === this.state.start;\n        return this.parseParenAndDistinguishExpression(canBeArrow);\n      }\n\n      case tt.bracketBarL:\n      case tt.bracketHashL: {\n        return this.parseArrayLike(\n          this.state.type === tt.bracketBarL ? tt.bracketBarR : tt.bracketR,\n          /* canBePattern */ false,\n          /* isTuple */ true,\n        );\n      }\n      case tt.bracketL: {\n        return this.parseArrayLike(\n          tt.bracketR,\n          /* canBePattern */ true,\n          /* isTuple */ false,\n          refExpressionErrors,\n        );\n      }\n      case tt.braceBarL:\n      case tt.braceHashL: {\n        return this.parseObjectLike(\n          this.state.type === tt.braceBarL ? tt.braceBarR : tt.braceR,\n          /* isPattern */ false,\n          /* isRecord */ true,\n        );\n      }\n      case tt.braceL: {\n        return this.parseObjectLike(\n          tt.braceR,\n          /* isPattern */ false,\n          /* isRecord */ false,\n          refExpressionErrors,\n        );\n      }\n      case tt._function:\n        return this.parseFunctionOrFunctionSent();\n\n      case tt.at:\n        decorators = this.parseDecorators();\n      // fall through\n      case tt._class:\n        return this.parseClass(\n          this.maybeTakeDecorators(decorators, this.startNode()),\n          false,\n        );\n\n      case tt._new:\n        return this.parseNewOrNewTarget();\n\n      case tt.templateNonTail:\n      case tt.templateTail:\n        return this.parseTemplate(false);\n\n      // BindExpression[Yield]\n      //   :: MemberExpression[?Yield]\n      case tt.doubleColon: {\n        node = this.startNode();\n        this.next();\n        node.object = null;\n        const callee = (node.callee = this.parseNoCallExpr());\n        if (callee.type === \"MemberExpression\") {\n          return this.finishNode(node, \"BindExpression\");\n        } else {\n          throw this.raise(Errors.UnsupportedBind, { at: callee });\n        }\n      }\n\n      case tt.privateName: {\n        // Standalone private names are only allowed in \"#x in obj\"\n        // expressions, and they are directly handled by callers of\n        // parseExprOp. If we reach this, the input is always invalid.\n        // We can throw a better error message and recover, rather than\n        // just throwing \"Unexpected token\" (which is the default\n        // behavior of this big switch statement).\n        this.raise(Errors.PrivateInExpectedIn, {\n          at: this.state.startLoc,\n          identifierName: this.state.value,\n        });\n        return this.parsePrivateName();\n      }\n\n      case tt.moduloAssign: {\n        return this.parseTopicReferenceThenEqualsSign(tt.modulo, \"%\");\n      }\n\n      case tt.xorAssign: {\n        return this.parseTopicReferenceThenEqualsSign(tt.bitwiseXOR, \"^\");\n      }\n\n      case tt.doubleCaret:\n      case tt.doubleAt: {\n        return this.parseTopicReference(\"hack\");\n      }\n\n      case tt.bitwiseXOR:\n      case tt.modulo:\n      case tt.hash: {\n        const pipeProposal = this.getPluginOption(\n          \"pipelineOperator\",\n          \"proposal\",\n        );\n\n        if (pipeProposal) {\n          return this.parseTopicReference(pipeProposal);\n        }\n        this.unexpected();\n        break;\n      }\n\n      case tt.lt: {\n        const lookaheadCh = this.input.codePointAt(this.nextTokenStart());\n        if (\n          isIdentifierStart(lookaheadCh) || // Element/Type Parameter <foo>\n          lookaheadCh === charCodes.greaterThan // Fragment <>\n        ) {\n          this.expectOnePlugin([\"jsx\", \"flow\", \"typescript\"]);\n        } else {\n          this.unexpected();\n        }\n        break;\n      }\n\n      default:\n        if (tokenIsIdentifier(type)) {\n          if (\n            this.isContextual(tt._module) &&\n            this.lookaheadInLineCharCode() === charCodes.leftCurlyBrace\n          ) {\n            return this.parseModuleExpression();\n          }\n          const canBeArrow = this.state.potentialArrowAt === this.state.start;\n          const containsEsc = this.state.containsEsc;\n          const id = this.parseIdentifier();\n\n          if (\n            !containsEsc &&\n            id.name === \"async\" &&\n            !this.canInsertSemicolon()\n          ) {\n            const { type } = this.state;\n            if (type === tt._function) {\n              this.resetPreviousNodeTrailingComments(id);\n              this.next();\n              return this.parseAsyncFunctionExpression(\n                this.startNodeAtNode(id),\n              );\n            } else if (tokenIsIdentifier(type)) {\n              // If the next token begins with \"=\", commit to parsing an async\n              // arrow function. (Peeking ahead for \"=\" lets us avoid a more\n              // expensive full-token lookahead on this common path.)\n              if (this.lookaheadCharCode() === charCodes.equalsTo) {\n                // although `id` is not used in async arrow unary function,\n                // we don't need to reset `async`'s trailing comments because\n                // it will be attached to the upcoming async arrow binding identifier\n                return this.parseAsyncArrowUnaryFunction(\n                  this.startNodeAtNode(id),\n                );\n              } else {\n                // Otherwise, treat \"async\" as an identifier and let calling code\n                // deal with the current tt.name token.\n                return id;\n              }\n            } else if (type === tt._do) {\n              this.resetPreviousNodeTrailingComments(id);\n              return this.parseDo(this.startNodeAtNode(id), true);\n            }\n          }\n\n          if (\n            canBeArrow &&\n            this.match(tt.arrow) &&\n            !this.canInsertSemicolon()\n          ) {\n            this.next();\n            return this.parseArrowExpression(\n              this.startNodeAtNode(id),\n              [id],\n              false,\n            );\n          }\n\n          return id;\n        } else {\n          this.unexpected();\n        }\n    }\n  }\n\n  // This helper method should only be called\n  // when the parser has reached a potential Hack pipe topic token\n  // that is followed by an equals sign.\n  // See <https://github.com/js-choi/proposal-hack-pipes>.\n  // If we find ^= or %= in an expression position\n  // (i.e., the tt.moduloAssign or tt.xorAssign token types), and if the\n  // Hack-pipes proposal is active with ^ or % as its topicToken, then the ^ or\n  // % could be the topic token (e.g., in x |> ^==y or x |> ^===y), and so we\n  // reparse the current token as ^ or %.\n  // Otherwise, this throws an unexpected-token error.\n  parseTopicReferenceThenEqualsSign(\n    topicTokenType: TokenType,\n    topicTokenValue: string,\n  ): N.Expression {\n    const pipeProposal = this.getPluginOption(\"pipelineOperator\", \"proposal\");\n\n    if (pipeProposal) {\n      // Set the most-recent token to be a topic token\n      // given by the tokenType and tokenValue.\n      // Now the next readToken() call (in parseTopicReference)\n      // will consume that “topic token”.\n      this.state.type = topicTokenType;\n      this.state.value = topicTokenValue;\n      // Rewind the tokenizer to the end of the “topic token”, so that the\n      // following token starts at the equals sign after that topic token.\n      this.state.pos--;\n      this.state.end--;\n      // This is safe to do since the preceding character was either ^ or %, and\n      // thus not a newline.\n      this.state.endLoc = createPositionWithColumnOffset(this.state.endLoc, -1);\n      // Now actually consume the topic token.\n      return this.parseTopicReference(pipeProposal);\n    } else {\n      this.unexpected();\n    }\n  }\n\n  // This helper method should only be called\n  // when the proposal-pipeline-operator plugin is active,\n  // and when the parser has reached a potential Hack pipe topic token.\n  // Although a pipe-operator proposal is assumed to be active,\n  // its configuration might not match the current token’s type.\n  // See <https://github.com/js-choi/proposal-hack-pipes>.\n  parseTopicReference(pipeProposal: string): N.Expression {\n    const node = this.startNode<N.TopicReference>();\n    const startLoc = this.state.startLoc;\n    const tokenType = this.state.type;\n\n    // Consume the current token.\n    this.next();\n\n    // If the pipe-operator plugin’s configuration matches the current token’s type,\n    // then this will return `node`, will have been finished as a topic reference.\n    // Otherwise, this will throw a `PipeTopicUnconfiguredToken` error.\n    return this.finishTopicReference(node, startLoc, pipeProposal, tokenType);\n  }\n\n  // This helper method attempts to finish the given `node`\n  // into a topic-reference node for the given `pipeProposal`.\n  // See <https://github.com/js-choi/proposal-hack-pipes>.\n  //\n  // The method assumes that any topic token was consumed before it was called.\n  //\n  // If the `pipelineOperator` plugin is active,\n  // and if the given `tokenType` matches the plugin’s configuration,\n  // then this method will return the finished `node`.\n  //\n  // If the `pipelineOperator` plugin is active,\n  // but if the given `tokenType` does not match the plugin’s configuration,\n  // then this method will throw a `PipeTopicUnconfiguredToken` error.\n  finishTopicReference(\n    node: Undone<N.Node>,\n    startLoc: Position,\n    pipeProposal: string,\n    tokenType: TokenType,\n  ): N.Expression {\n    if (\n      this.testTopicReferenceConfiguration(pipeProposal, startLoc, tokenType)\n    ) {\n      // The token matches the plugin’s configuration.\n      // The token is therefore a topic reference.\n\n      // Determine the node type for the topic reference\n      // that is appropriate for the active pipe-operator proposal.\n      const nodeType =\n        pipeProposal === \"smart\"\n          ? \"PipelinePrimaryTopicReference\"\n          : // The proposal must otherwise be \"hack\",\n            // as enforced by testTopicReferenceConfiguration.\n            \"TopicReference\";\n\n      if (!this.topicReferenceIsAllowedInCurrentContext()) {\n        this.raise(\n          // The topic reference is not allowed in the current context:\n          // it is outside of a pipe body.\n          // Raise recoverable errors.\n          pipeProposal === \"smart\"\n            ? Errors.PrimaryTopicNotAllowed\n            : // In this case, `pipeProposal === \"hack\"` is true.\n              Errors.PipeTopicUnbound,\n          { at: startLoc },\n        );\n      }\n\n      // Register the topic reference so that its pipe body knows\n      // that its topic was used at least once.\n      this.registerTopicReference();\n\n      return this.finishNode(node, nodeType);\n    } else {\n      // The token does not match the plugin’s configuration.\n      throw this.raise(Errors.PipeTopicUnconfiguredToken, {\n        at: startLoc,\n        token: tokenLabelName(tokenType),\n      });\n    }\n  }\n\n  // This helper method tests whether the given token type\n  // matches the pipelineOperator parser plugin’s configuration.\n  // If the active pipe proposal is Hack style,\n  // and if the given token is the same as the plugin configuration’s `topicToken`,\n  // then this is a valid topic reference.\n  // If the active pipe proposal is smart mix,\n  // then the topic token must always be `#`.\n  // If the active pipe proposal is neither (e.g., \"minimal\" or \"fsharp\"),\n  // then an error is thrown.\n  testTopicReferenceConfiguration(\n    pipeProposal: string,\n    startLoc: Position,\n    tokenType: TokenType,\n  ): boolean {\n    switch (pipeProposal) {\n      case \"hack\": {\n        return this.hasPlugin([\n          \"pipelineOperator\",\n          {\n            // @ts-expect-error token must have a label\n            topicToken: tokenLabelName(tokenType),\n          },\n        ]);\n      }\n      case \"smart\":\n        return tokenType === tt.hash;\n      default:\n        throw this.raise(Errors.PipeTopicRequiresHackPipes, { at: startLoc });\n    }\n  }\n\n  // async [no LineTerminator here] AsyncArrowBindingIdentifier[?Yield] [no LineTerminator here] => AsyncConciseBody[?In]\n  parseAsyncArrowUnaryFunction(\n    this: Parser,\n    node: Undone<N.ArrowFunctionExpression>,\n  ): N.ArrowFunctionExpression {\n    // We don't need to push a new ParameterDeclarationScope here since we are sure\n    // 1) it is an async arrow, 2) no biding pattern is allowed in params\n    this.prodParam.enter(functionFlags(true, this.prodParam.hasYield));\n    const params = [this.parseIdentifier()];\n    this.prodParam.exit();\n    if (this.hasPrecedingLineBreak()) {\n      this.raise(Errors.LineTerminatorBeforeArrow, {\n        at: this.state.curPosition(),\n      });\n    }\n    this.expect(tt.arrow);\n    // let foo = async bar => {};\n    return this.parseArrowExpression(node, params, true);\n  }\n\n  // https://github.com/tc39/proposal-do-expressions\n  // https://github.com/tc39/proposal-async-do-expressions\n  parseDo(\n    this: Parser,\n    node: Undone<N.DoExpression>,\n    isAsync: boolean,\n  ): N.DoExpression {\n    this.expectPlugin(\"doExpressions\");\n    if (isAsync) {\n      this.expectPlugin(\"asyncDoExpressions\");\n    }\n    node.async = isAsync;\n    this.next(); // eat `do`\n    const oldLabels = this.state.labels;\n    this.state.labels = [];\n    if (isAsync) {\n      // AsyncDoExpression :\n      // async [no LineTerminator here] do Block[~Yield, +Await, ~Return]\n      this.prodParam.enter(PARAM_AWAIT);\n      node.body = this.parseBlock();\n      this.prodParam.exit();\n    } else {\n      node.body = this.parseBlock();\n    }\n\n    this.state.labels = oldLabels;\n    return this.finishNode(node, \"DoExpression\");\n  }\n\n  // Parse the `super` keyword\n  parseSuper(): N.Super {\n    const node = this.startNode<N.Super>();\n    this.next(); // eat `super`\n    if (\n      this.match(tt.parenL) &&\n      !this.scope.allowDirectSuper &&\n      !this.options.allowSuperOutsideMethod\n    ) {\n      this.raise(Errors.SuperNotAllowed, { at: node });\n    } else if (\n      !this.scope.allowSuper &&\n      !this.options.allowSuperOutsideMethod\n    ) {\n      this.raise(Errors.UnexpectedSuper, { at: node });\n    }\n\n    if (\n      !this.match(tt.parenL) &&\n      !this.match(tt.bracketL) &&\n      !this.match(tt.dot)\n    ) {\n      this.raise(Errors.UnsupportedSuper, { at: node });\n    }\n\n    return this.finishNode(node, \"Super\");\n  }\n\n  parsePrivateName(): N.PrivateName {\n    const node = this.startNode<N.PrivateName>();\n    const id = this.startNodeAt<N.Identifier>(\n      // The position is hardcoded because we merge `#` and name into a single\n      // tt.privateName token\n      createPositionWithColumnOffset(this.state.startLoc, 1),\n    );\n    const name = this.state.value;\n    this.next(); // eat #name;\n    node.id = this.createIdentifier(id, name);\n    return this.finishNode(node, \"PrivateName\");\n  }\n\n  parseFunctionOrFunctionSent(\n    this: Parser,\n  ): N.FunctionExpression | N.MetaProperty {\n    const node = this.startNode<N.FunctionExpression | N.MetaProperty>();\n\n    // We do not do parseIdentifier here because when parseFunctionOrFunctionSent\n    // is called we already know that the current token is a \"name\" with the value \"function\"\n    // This will improve perf a tiny little bit as we do not do validation but more importantly\n    // here is that parseIdentifier will remove an item from the expression stack\n    // if \"function\" or \"class\" is parsed as identifier (in objects e.g.), which should not happen here.\n    this.next(); // eat `function`\n\n    if (this.prodParam.hasYield && this.match(tt.dot)) {\n      const meta = this.createIdentifier(\n        this.startNodeAtNode<N.Identifier>(node),\n        \"function\",\n      );\n      this.next(); // eat `.`\n      // https://github.com/tc39/proposal-function.sent#syntax-1\n      if (this.match(tt._sent)) {\n        this.expectPlugin(\"functionSent\");\n      } else if (!this.hasPlugin(\"functionSent\")) {\n        // The code wasn't `function.sent` but just `function.`, so a simple error is less confusing.\n        this.unexpected();\n      }\n      return this.parseMetaProperty(\n        node as Undone<N.MetaProperty>,\n        meta,\n        \"sent\",\n      );\n    }\n    return this.parseFunction(node as Undone<N.FunctionExpression>);\n  }\n\n  parseMetaProperty(\n    node: Undone<N.MetaProperty>,\n    meta: N.Identifier,\n    propertyName: string,\n  ): N.MetaProperty {\n    node.meta = meta;\n\n    const containsEsc = this.state.containsEsc;\n\n    node.property = this.parseIdentifier(true);\n\n    if (node.property.name !== propertyName || containsEsc) {\n      this.raise(Errors.UnsupportedMetaProperty, {\n        at: node.property,\n        target: meta.name,\n        onlyValidPropertyName: propertyName,\n      });\n    }\n\n    return this.finishNode(node, \"MetaProperty\");\n  }\n\n  // https://tc39.es/ecma262/#prod-ImportMeta\n  parseImportMetaProperty(node: Undone<N.MetaProperty>): N.MetaProperty {\n    const id = this.createIdentifier(\n      this.startNodeAtNode<N.Identifier>(node),\n      \"import\",\n    );\n    this.next(); // eat `.`\n\n    if (this.isContextual(tt._meta)) {\n      if (!this.inModule) {\n        this.raise(Errors.ImportMetaOutsideModule, { at: id });\n      }\n      this.sawUnambiguousESM = true;\n    }\n\n    return this.parseMetaProperty(node, id, \"meta\");\n  }\n\n  parseLiteralAtNode<T extends N.Node>(\n    value: any,\n    type: T[\"type\"],\n    node: any,\n  ): T {\n    this.addExtra(node, \"rawValue\", value);\n    this.addExtra(node, \"raw\", this.input.slice(node.start, this.state.end));\n    node.value = value;\n    this.next();\n    return this.finishNode<T>(node, type);\n  }\n\n  parseLiteral<T extends N.Node>(value: any, type: T[\"type\"]): T {\n    const node = this.startNode();\n    return this.parseLiteralAtNode(value, type, node);\n  }\n\n  parseStringLiteral(value: any) {\n    return this.parseLiteral<N.StringLiteral>(value, \"StringLiteral\");\n  }\n\n  parseNumericLiteral(value: any) {\n    return this.parseLiteral<N.NumericLiteral>(value, \"NumericLiteral\");\n  }\n\n  parseBigIntLiteral(value: any) {\n    return this.parseLiteral<N.BigIntLiteral>(value, \"BigIntLiteral\");\n  }\n\n  parseDecimalLiteral(value: any) {\n    return this.parseLiteral<N.DecimalLiteral>(value, \"DecimalLiteral\");\n  }\n\n  parseRegExpLiteral(value: {\n    value: any;\n    pattern: string;\n    flags: N.RegExpLiteral[\"flags\"];\n  }) {\n    const node = this.parseLiteral<N.RegExpLiteral>(\n      value.value,\n      \"RegExpLiteral\",\n    );\n    node.pattern = value.pattern;\n    node.flags = value.flags;\n    return node;\n  }\n\n  parseBooleanLiteral(value: boolean) {\n    const node = this.startNode<N.BooleanLiteral>();\n    node.value = value;\n    this.next();\n    return this.finishNode(node, \"BooleanLiteral\");\n  }\n\n  parseNullLiteral() {\n    const node = this.startNode<N.NullLiteral>();\n    this.next();\n    return this.finishNode(node, \"NullLiteral\");\n  }\n\n  // https://tc39.es/ecma262/#prod-CoverParenthesizedExpressionAndArrowParameterList\n  parseParenAndDistinguishExpression(\n    this: Parser,\n    canBeArrow: boolean,\n  ): N.Expression {\n    const startLoc = this.state.startLoc;\n\n    let val;\n    this.next(); // eat `(`\n    this.expressionScope.enter(newArrowHeadScope());\n\n    const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;\n    const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;\n    this.state.maybeInArrowParameters = true;\n    this.state.inFSharpPipelineDirectBody = false;\n\n    const innerStartLoc = this.state.startLoc;\n    const exprList: N.Expression[] = [];\n    const refExpressionErrors = new ExpressionErrors();\n    let first = true;\n    let spreadStartLoc;\n    let optionalCommaStartLoc;\n\n    while (!this.match(tt.parenR)) {\n      if (first) {\n        first = false;\n      } else {\n        this.expect(\n          tt.comma,\n          refExpressionErrors.optionalParametersLoc === null\n            ? null\n            : refExpressionErrors.optionalParametersLoc,\n        );\n        if (this.match(tt.parenR)) {\n          optionalCommaStartLoc = this.state.startLoc;\n          break;\n        }\n      }\n\n      if (this.match(tt.ellipsis)) {\n        const spreadNodeStartLoc = this.state.startLoc;\n        spreadStartLoc = this.state.startLoc;\n        exprList.push(\n          this.parseParenItem(this.parseRestBinding(), spreadNodeStartLoc),\n        );\n\n        if (!this.checkCommaAfterRest(charCodes.rightParenthesis)) {\n          break;\n        }\n      } else {\n        exprList.push(\n          this.parseMaybeAssignAllowIn(\n            refExpressionErrors,\n            this.parseParenItem,\n          ),\n        );\n      }\n    }\n\n    const innerEndLoc = this.state.lastTokEndLoc;\n    this.expect(tt.parenR);\n\n    this.state.maybeInArrowParameters = oldMaybeInArrowParameters;\n    this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;\n\n    let arrowNode = this.startNodeAt<N.ArrowFunctionExpression>(startLoc);\n    if (\n      canBeArrow &&\n      this.shouldParseArrow(exprList) &&\n      (arrowNode = this.parseArrow(arrowNode))\n    ) {\n      this.checkDestructuringPrivate(refExpressionErrors);\n      this.expressionScope.validateAsPattern();\n      this.expressionScope.exit();\n      this.parseArrowExpression(arrowNode, exprList, false);\n      // @ts-expect-error todo(flow->ts) improve node types\n      return arrowNode;\n    }\n    this.expressionScope.exit();\n\n    if (!exprList.length) {\n      this.unexpected(this.state.lastTokStartLoc);\n    }\n    if (optionalCommaStartLoc) this.unexpected(optionalCommaStartLoc);\n    if (spreadStartLoc) this.unexpected(spreadStartLoc);\n    this.checkExpressionErrors(refExpressionErrors, true);\n\n    this.toReferencedListDeep(exprList, /* isParenthesizedExpr */ true);\n    if (exprList.length > 1) {\n      val = this.startNodeAt<N.SequenceExpression>(innerStartLoc);\n      val.expressions = exprList;\n      // finish node at current location so it can pick up comments after `)`\n      this.finishNode(val, \"SequenceExpression\");\n      this.resetEndLocation(val, innerEndLoc);\n    } else {\n      val = exprList[0];\n    }\n\n    return this.wrapParenthesis(\n      startLoc,\n      // @ts-expect-error todo(flow->ts)\n      val,\n    );\n  }\n\n  wrapParenthesis(startLoc: Position, expression: N.Expression): N.Expression {\n    if (!this.options.createParenthesizedExpressions) {\n      this.addExtra(expression, \"parenthesized\", true);\n      this.addExtra(expression, \"parenStart\", startLoc.index);\n\n      this.takeSurroundingComments(\n        expression,\n        startLoc.index,\n        this.state.lastTokEndLoc.index,\n      );\n\n      return expression;\n    }\n\n    const parenExpression =\n      this.startNodeAt<N.ParenthesizedExpression>(startLoc);\n    parenExpression.expression = expression;\n    return this.finishNode(parenExpression, \"ParenthesizedExpression\");\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars -- `params` is used in typescript plugin\n  shouldParseArrow(params: Array<N.Node>): boolean {\n    return !this.canInsertSemicolon();\n  }\n\n  parseArrow(\n    node: Undone<N.ArrowFunctionExpression>,\n  ): Undone<N.ArrowFunctionExpression> | undefined {\n    if (this.eat(tt.arrow)) {\n      return node;\n    }\n  }\n\n  parseParenItem(\n    node: N.Expression,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    startLoc: Position,\n  ): N.Expression {\n    return node;\n  }\n\n  parseNewOrNewTarget(this: Parser): N.NewExpression | N.MetaProperty {\n    const node = this.startNode<N.NewExpression | N.MetaProperty>();\n    this.next();\n    if (this.match(tt.dot)) {\n      // https://tc39.es/ecma262/#prod-NewTarget\n      const meta = this.createIdentifier(\n        this.startNodeAtNode<N.Identifier>(node),\n        \"new\",\n      );\n      this.next();\n      const metaProp = this.parseMetaProperty(\n        node as Undone<N.MetaProperty>,\n        meta,\n        \"target\",\n      );\n\n      if (\n        !this.scope.inNonArrowFunction &&\n        !this.scope.inClass &&\n        !this.options.allowNewTargetOutsideFunction\n      ) {\n        this.raise(Errors.UnexpectedNewTarget, { at: metaProp });\n      }\n\n      return metaProp;\n    }\n\n    return this.parseNew(node as Undone<N.NewExpression>);\n  }\n\n  // New's precedence is slightly tricky. It must allow its argument to\n  // be a `[]` or dot subscript expression, but not a call — at least,\n  // not without wrapping it in parentheses. Thus, it uses the noCalls\n  // argument to parseSubscripts to prevent it from consuming the\n  // argument list.\n  // https://tc39.es/ecma262/#prod-NewExpression\n  parseNew(this: Parser, node: Undone<N.NewExpression>): N.NewExpression {\n    this.parseNewCallee(node);\n\n    if (this.eat(tt.parenL)) {\n      const args = this.parseExprList(tt.parenR);\n      this.toReferencedList(args);\n      // (parseExprList should be all non-null in this case)\n      node.arguments = args;\n    } else {\n      node.arguments = [];\n    }\n\n    return this.finishNode(node, \"NewExpression\");\n  }\n\n  parseNewCallee(this: Parser, node: Undone<N.NewExpression>): void {\n    node.callee = this.parseNoCallExpr();\n    if (node.callee.type === \"Import\") {\n      this.raise(Errors.ImportCallNotNewExpression, { at: node.callee });\n    }\n  }\n\n  // Parse template expression.\n\n  parseTemplateElement(isTagged: boolean): N.TemplateElement {\n    const { start, startLoc, end, value } = this.state;\n    const elemStart = start + 1;\n    const elem = this.startNodeAt<N.TemplateElement>(\n      createPositionWithColumnOffset(startLoc, 1),\n    );\n    if (value === null) {\n      if (!isTagged) {\n        this.raise(Errors.InvalidEscapeSequenceTemplate, {\n          // FIXME: Adding 1 is probably wrong.\n          at: createPositionWithColumnOffset(\n            this.state.firstInvalidTemplateEscapePos,\n            1,\n          ),\n        });\n      }\n    }\n\n    const isTail = this.match(tt.templateTail);\n    const endOffset = isTail ? -1 : -2;\n    const elemEnd = end + endOffset;\n    elem.value = {\n      raw: this.input.slice(elemStart, elemEnd).replace(/\\r\\n?/g, \"\\n\"),\n      cooked: value === null ? null : value.slice(1, endOffset),\n    };\n    elem.tail = isTail;\n    this.next();\n    const finishedNode = this.finishNode(elem, \"TemplateElement\");\n    this.resetEndLocation(\n      finishedNode,\n      createPositionWithColumnOffset(this.state.lastTokEndLoc, endOffset),\n    );\n    return finishedNode;\n  }\n\n  // https://tc39.es/ecma262/#prod-TemplateLiteral\n  parseTemplate(this: Parser, isTagged: boolean): N.TemplateLiteral {\n    const node = this.startNode<N.TemplateLiteral>();\n    node.expressions = [];\n    let curElt = this.parseTemplateElement(isTagged);\n    node.quasis = [curElt];\n    while (!curElt.tail) {\n      node.expressions.push(this.parseTemplateSubstitution());\n      this.readTemplateContinuation();\n      node.quasis.push((curElt = this.parseTemplateElement(isTagged)));\n    }\n    return this.finishNode(node, \"TemplateLiteral\");\n  }\n\n  // This is overwritten by the TypeScript plugin to parse template types\n  parseTemplateSubstitution(this: Parser): N.Expression {\n    return this.parseExpression();\n  }\n\n  // Parse an object literal, binding pattern, or record.\n\n  parseObjectLike(\n    close: TokenType,\n    isPattern: true,\n    isRecord?: boolean | null,\n    refExpressionErrors?: ExpressionErrors | null,\n  ): N.ObjectPattern;\n  parseObjectLike(\n    close: TokenType,\n    isPattern: false,\n    isRecord?: false | null,\n    refExpressionErrors?: ExpressionErrors | null,\n  ): N.ObjectExpression;\n  parseObjectLike(\n    close: TokenType,\n    isPattern: false,\n    isRecord?: true,\n    refExpressionErrors?: ExpressionErrors | null,\n  ): N.RecordExpression;\n  parseObjectLike<T extends N.ObjectPattern | N.ObjectExpression>(\n    this: Parser,\n    close: TokenType,\n    isPattern: boolean,\n    isRecord?: boolean | null,\n    refExpressionErrors?: ExpressionErrors | null,\n  ): T {\n    if (isRecord) {\n      this.expectPlugin(\"recordAndTuple\");\n    }\n    const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;\n    this.state.inFSharpPipelineDirectBody = false;\n    const propHash: any = Object.create(null);\n    let first = true;\n    const node = this.startNode<\n      N.ObjectExpression | N.ObjectPattern | N.RecordExpression\n    >();\n\n    node.properties = [];\n    this.next();\n\n    while (!this.match(close)) {\n      if (first) {\n        first = false;\n      } else {\n        this.expect(tt.comma);\n        if (this.match(close)) {\n          this.addTrailingCommaExtraToNode(\n            // @ts-expect-error todo(flow->ts) improve node types\n            node,\n          );\n          break;\n        }\n      }\n\n      let prop;\n      if (isPattern) {\n        prop = this.parseBindingProperty();\n      } else {\n        prop = this.parsePropertyDefinition(refExpressionErrors);\n        this.checkProto(prop, isRecord, propHash, refExpressionErrors);\n      }\n\n      if (\n        isRecord &&\n        !this.isObjectProperty(prop) &&\n        prop.type !== \"SpreadElement\"\n      ) {\n        this.raise(Errors.InvalidRecordProperty, { at: prop });\n      }\n\n      // @ts-expect-error shorthand may not index prop\n      if (prop.shorthand) {\n        this.addExtra(prop, \"shorthand\", true);\n      }\n\n      // @ts-expect-error Fixme: refine typings\n      node.properties.push(prop);\n    }\n\n    this.next();\n\n    this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;\n    let type = \"ObjectExpression\";\n    if (isPattern) {\n      type = \"ObjectPattern\";\n    } else if (isRecord) {\n      type = \"RecordExpression\";\n    }\n    // @ts-expect-error type is well defined\n    return this.finishNode(node, type);\n  }\n\n  addTrailingCommaExtraToNode(node: N.Node): void {\n    this.addExtra(node, \"trailingComma\", this.state.lastTokStart);\n    this.addExtra(node, \"trailingCommaLoc\", this.state.lastTokStartLoc, false);\n  }\n\n  // Check grammar production:\n  //   IdentifierName *_opt PropertyName\n  // It is used in `parsePropertyDefinition` to detect AsyncMethod and Accessors\n  maybeAsyncOrAccessorProp(prop: Undone<N.ObjectProperty>): boolean {\n    return (\n      !prop.computed &&\n      prop.key.type === \"Identifier\" &&\n      (this.isLiteralPropertyName() ||\n        this.match(tt.bracketL) ||\n        this.match(tt.star))\n    );\n  }\n\n  // https://tc39.es/ecma262/#prod-PropertyDefinition\n  parsePropertyDefinition(\n    this: Parser,\n    refExpressionErrors?: ExpressionErrors | null,\n  ): N.ObjectMember | N.SpreadElement {\n    let decorators = [];\n    if (this.match(tt.at)) {\n      if (this.hasPlugin(\"decorators\")) {\n        this.raise(Errors.UnsupportedPropertyDecorator, {\n          at: this.state.startLoc,\n        });\n      }\n\n      // we needn't check if decorators (stage 0) plugin is enabled since it's checked by\n      // the call to this.parseDecorator\n      while (this.match(tt.at)) {\n        decorators.push(this.parseDecorator());\n      }\n    }\n\n    const prop = this.startNode<N.ObjectProperty>();\n    let isAsync = false;\n    let isAccessor = false;\n    let startLoc;\n\n    if (this.match(tt.ellipsis)) {\n      if (decorators.length) this.unexpected();\n      return this.parseSpread();\n    }\n\n    if (decorators.length) {\n      prop.decorators = decorators;\n      decorators = [];\n    }\n\n    prop.method = false;\n\n    if (refExpressionErrors) {\n      startLoc = this.state.startLoc;\n    }\n\n    let isGenerator = this.eat(tt.star);\n    this.parsePropertyNamePrefixOperator(prop);\n    const containsEsc = this.state.containsEsc;\n    const key = this.parsePropertyName(prop, refExpressionErrors);\n\n    if (!isGenerator && !containsEsc && this.maybeAsyncOrAccessorProp(prop)) {\n      const keyName = key.name;\n      // https://tc39.es/ecma262/#prod-AsyncMethod\n      // https://tc39.es/ecma262/#prod-AsyncGeneratorMethod\n      if (keyName === \"async\" && !this.hasPrecedingLineBreak()) {\n        isAsync = true;\n        this.resetPreviousNodeTrailingComments(key);\n        isGenerator = this.eat(tt.star);\n        this.parsePropertyName(prop);\n      }\n      // get PropertyName[?Yield, ?Await] () { FunctionBody[~Yield, ~Await] }\n      // set PropertyName[?Yield, ?Await] ( PropertySetParameterList ) { FunctionBody[~Yield, ~Await] }\n      if (keyName === \"get\" || keyName === \"set\") {\n        isAccessor = true;\n        this.resetPreviousNodeTrailingComments(key);\n        prop.kind = keyName;\n        if (this.match(tt.star)) {\n          isGenerator = true;\n          this.raise(Errors.AccessorIsGenerator, {\n            at: this.state.curPosition(),\n            kind: keyName,\n          });\n          this.next();\n        }\n        this.parsePropertyName(prop);\n      }\n    }\n\n    return this.parseObjPropValue(\n      prop,\n      startLoc,\n      isGenerator,\n      isAsync,\n      false /* isPattern */,\n      isAccessor,\n      refExpressionErrors,\n    );\n  }\n\n  getGetterSetterExpectedParamCount(\n    method: N.ObjectMethod | N.ClassMethod,\n  ): number {\n    return method.kind === \"get\" ? 0 : 1;\n  }\n\n  // This exists so we can override within the ESTree plugin\n  getObjectOrClassMethodParams(method: N.ObjectMethod | N.ClassMethod) {\n    return method.params;\n  }\n\n  // get methods aren't allowed to have any parameters\n  // set methods must have exactly 1 parameter which is not a rest parameter\n  checkGetterSetterParams(method: N.ObjectMethod | N.ClassMethod): void {\n    const paramCount = this.getGetterSetterExpectedParamCount(method);\n    const params = this.getObjectOrClassMethodParams(method);\n\n    if (params.length !== paramCount) {\n      this.raise(\n        method.kind === \"get\" ? Errors.BadGetterArity : Errors.BadSetterArity,\n        { at: method },\n      );\n    }\n\n    if (\n      method.kind === \"set\" &&\n      params[params.length - 1]?.type === \"RestElement\"\n    ) {\n      this.raise(Errors.BadSetterRestParameter, { at: method });\n    }\n  }\n\n  // https://tc39.es/ecma262/#prod-MethodDefinition\n  parseObjectMethod(\n    this: Parser,\n    prop: Undone<N.ObjectMethod>,\n    isGenerator: boolean,\n    isAsync: boolean,\n    isPattern: boolean,\n    isAccessor: boolean,\n  ): N.ObjectMethod | undefined | null {\n    if (isAccessor) {\n      // isAccessor implies isAsync: false, isPattern: false, isGenerator: false\n      const finishedProp = this.parseMethod(\n        prop,\n        // This _should_ be false, but with error recovery, we allow it to be\n        // set for informational purposes\n        isGenerator,\n        /* isAsync */ false,\n        /* isConstructor */ false,\n        false,\n        \"ObjectMethod\",\n      );\n      this.checkGetterSetterParams(finishedProp);\n      return finishedProp;\n    }\n\n    if (isAsync || isGenerator || this.match(tt.parenL)) {\n      if (isPattern) this.unexpected();\n      prop.kind = \"method\";\n      prop.method = true;\n      return this.parseMethod(\n        prop,\n        isGenerator,\n        isAsync,\n        /* isConstructor */ false,\n        false,\n        \"ObjectMethod\",\n      );\n    }\n  }\n\n  // if `isPattern` is true, parse https://tc39.es/ecma262/#prod-BindingProperty\n  // else https://tc39.es/ecma262/#prod-PropertyDefinition\n  parseObjectProperty(\n    this: Parser,\n    prop: Undone<N.ObjectProperty>,\n    startLoc: Position | undefined | null,\n    isPattern: boolean,\n    refExpressionErrors?: ExpressionErrors | null,\n  ): N.ObjectProperty | undefined | null {\n    prop.shorthand = false;\n\n    if (this.eat(tt.colon)) {\n      prop.value = isPattern\n        ? this.parseMaybeDefault(this.state.startLoc)\n        : this.parseMaybeAssignAllowIn(refExpressionErrors);\n\n      return this.finishNode(prop, \"ObjectProperty\");\n    }\n\n    if (!prop.computed && prop.key.type === \"Identifier\") {\n      // PropertyDefinition:\n      //   IdentifierReference\n      //   CoverInitializedName\n      // Note: `{ eval } = {}` will be checked in `checkLVal` later.\n      this.checkReservedWord(prop.key.name, prop.key.loc.start, true, false);\n\n      if (isPattern) {\n        prop.value = this.parseMaybeDefault(\n          startLoc,\n          cloneIdentifier(prop.key),\n        );\n      } else if (this.match(tt.eq)) {\n        const shorthandAssignLoc = this.state.startLoc;\n        if (refExpressionErrors != null) {\n          if (refExpressionErrors.shorthandAssignLoc === null) {\n            refExpressionErrors.shorthandAssignLoc = shorthandAssignLoc;\n          }\n        } else {\n          this.raise(Errors.InvalidCoverInitializedName, {\n            at: shorthandAssignLoc,\n          });\n        }\n        prop.value = this.parseMaybeDefault(\n          startLoc,\n          cloneIdentifier(prop.key),\n        );\n      } else {\n        prop.value = cloneIdentifier(prop.key);\n      }\n      prop.shorthand = true;\n\n      return this.finishNode(prop, \"ObjectProperty\");\n    }\n  }\n\n  parseObjPropValue(\n    this: Parser,\n    prop: Undone<N.ObjectMethod | N.ObjectProperty>,\n    startLoc: Position | undefined | null,\n    isGenerator: boolean,\n    isAsync: boolean,\n    isPattern: boolean,\n    isAccessor: boolean,\n    refExpressionErrors?: ExpressionErrors | null,\n  ): N.ObjectMethod | N.ObjectProperty {\n    const node =\n      this.parseObjectMethod(\n        prop as Undone<N.ObjectMethod>,\n        isGenerator,\n        isAsync,\n        isPattern,\n        isAccessor,\n      ) ||\n      this.parseObjectProperty(\n        prop as Undone<N.ObjectProperty>,\n        startLoc,\n        isPattern,\n        refExpressionErrors,\n      );\n\n    if (!node) this.unexpected();\n\n    return node;\n  }\n\n  // https://tc39.es/ecma262/#prod-PropertyName\n  // when refExpressionErrors presents, it will parse private name\n  // and record the position of the first private name\n  parsePropertyName(\n    this: Parser,\n    prop:\n      | Undone<N.ObjectOrClassMember | N.ClassMember>\n      | N.TsNamedTypeElementBase,\n    refExpressionErrors?: ExpressionErrors | null,\n  ): N.Expression | N.Identifier {\n    if (this.eat(tt.bracketL)) {\n      (prop as Undone<N.ObjectOrClassMember>).computed = true;\n      prop.key = this.parseMaybeAssignAllowIn();\n      this.expect(tt.bracketR);\n    } else {\n      // We check if it's valid for it to be a private name when we push it.\n      const { type, value } = this.state;\n      let key;\n      // most un-computed property names are identifiers\n      if (tokenIsKeywordOrIdentifier(type)) {\n        key = this.parseIdentifier(true);\n      } else {\n        switch (type) {\n          case tt.num:\n            key = this.parseNumericLiteral(value);\n            break;\n          case tt.string:\n            key = this.parseStringLiteral(value);\n            break;\n          case tt.bigint:\n            key = this.parseBigIntLiteral(value);\n            break;\n          case tt.decimal:\n            key = this.parseDecimalLiteral(value);\n            break;\n          case tt.privateName: {\n            // the class private key has been handled in parseClassElementName\n            const privateKeyLoc = this.state.startLoc;\n            if (refExpressionErrors != null) {\n              if (refExpressionErrors.privateKeyLoc === null) {\n                refExpressionErrors.privateKeyLoc = privateKeyLoc;\n              }\n            } else {\n              this.raise(Errors.UnexpectedPrivateField, {\n                at: privateKeyLoc,\n              });\n            }\n            key = this.parsePrivateName();\n            break;\n          }\n          default:\n            this.unexpected();\n        }\n      }\n      (prop as any).key = key;\n      if (type !== tt.privateName) {\n        // ClassPrivateProperty is never computed, so we don't assign in that case.\n        prop.computed = false;\n      }\n    }\n\n    return prop.key;\n  }\n\n  // Initialize empty function node.\n\n  initFunction(node: N.BodilessFunctionOrMethodBase, isAsync: boolean): void {\n    node.id = null;\n    node.generator = false;\n    node.async = isAsync;\n  }\n\n  // Parse object or class method.\n\n  parseMethod<T extends N.ObjectMethod | N.ClassMethod | N.ClassPrivateMethod>(\n    this: Parser,\n    node: Undone<T>,\n    isGenerator: boolean,\n    isAsync: boolean,\n    isConstructor: boolean,\n    allowDirectSuper: boolean,\n    type: T[\"type\"],\n    inClassScope: boolean = false,\n  ): T {\n    this.initFunction(node, isAsync);\n    node.generator = isGenerator;\n    this.scope.enter(\n      SCOPE_FUNCTION |\n        SCOPE_SUPER |\n        (inClassScope ? SCOPE_CLASS : 0) |\n        (allowDirectSuper ? SCOPE_DIRECT_SUPER : 0),\n    );\n    this.prodParam.enter(functionFlags(isAsync, node.generator));\n    this.parseFunctionParams(node, isConstructor);\n    const finishedNode = this.parseFunctionBodyAndFinish(node, type, true);\n    this.prodParam.exit();\n    this.scope.exit();\n\n    return finishedNode;\n  }\n\n  // parse an array literal or tuple literal\n  // https://tc39.es/ecma262/#prod-ArrayLiteral\n  // https://tc39.es/proposal-record-tuple/#prod-TupleLiteral\n  parseArrayLike(\n    this: Parser,\n    close: TokenType,\n    canBePattern: boolean,\n    isTuple: boolean,\n    refExpressionErrors?: ExpressionErrors | null,\n  ): N.ArrayExpression | N.TupleExpression {\n    if (isTuple) {\n      this.expectPlugin(\"recordAndTuple\");\n    }\n    const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;\n    this.state.inFSharpPipelineDirectBody = false;\n    const node = this.startNode<N.ArrayExpression | N.TupleExpression>();\n    this.next();\n    node.elements = this.parseExprList(\n      close,\n      /* allowEmpty */ !isTuple,\n      refExpressionErrors,\n      // @ts-expect-error todo(flow->ts)\n      node,\n    );\n    this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;\n    return this.finishNode(\n      node,\n      isTuple ? \"TupleExpression\" : \"ArrayExpression\",\n    );\n  }\n\n  // Parse arrow function expression.\n  // If the parameters are provided, they will be converted to an\n  // assignable list.\n  parseArrowExpression(\n    this: Parser,\n    node: Undone<N.ArrowFunctionExpression>,\n    params: N.Expression[] | undefined | null,\n    isAsync: boolean,\n    trailingCommaLoc?: Position | null,\n  ): N.ArrowFunctionExpression {\n    this.scope.enter(SCOPE_FUNCTION | SCOPE_ARROW);\n    let flags = functionFlags(isAsync, false);\n    // ConciseBody[In] :\n    //   [lookahead ≠ {] ExpressionBody[?In, ~Await]\n    //   { FunctionBody[~Yield, ~Await] }\n    if (!this.match(tt.braceL) && this.prodParam.hasIn) {\n      flags |= PARAM_IN;\n    }\n    this.prodParam.enter(flags);\n    this.initFunction(node, isAsync);\n    const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;\n\n    if (params) {\n      this.state.maybeInArrowParameters = true;\n      this.setArrowFunctionParameters(node, params, trailingCommaLoc);\n    }\n    this.state.maybeInArrowParameters = false;\n    this.parseFunctionBody(node, true);\n\n    this.prodParam.exit();\n    this.scope.exit();\n    this.state.maybeInArrowParameters = oldMaybeInArrowParameters;\n\n    return this.finishNode(node, \"ArrowFunctionExpression\");\n  }\n\n  setArrowFunctionParameters(\n    node: Undone<N.ArrowFunctionExpression>,\n    params: N.Expression[],\n    trailingCommaLoc?: Position | null,\n  ): void {\n    this.toAssignableList(params, trailingCommaLoc, false);\n    node.params = params as (N.Pattern | N.TSParameterProperty)[];\n  }\n\n  parseFunctionBodyAndFinish<\n    T extends\n      | N.Function\n      | N.TSDeclareMethod\n      | N.TSDeclareFunction\n      | N.ClassPrivateMethod,\n  >(node: Undone<T>, type: T[\"type\"], isMethod: boolean = false): T {\n    // @ts-expect-error (node is not bodiless if we get here)\n    this.parseFunctionBody(node, false, isMethod);\n    return this.finishNode(node, type);\n  }\n\n  // Parse function body and check parameters.\n  parseFunctionBody(\n    this: Parser,\n    node: Undone<N.Function>,\n    allowExpression?: boolean | null,\n    isMethod: boolean = false,\n  ): void {\n    const isExpression = allowExpression && !this.match(tt.braceL);\n    this.expressionScope.enter(newExpressionScope());\n\n    if (isExpression) {\n      // https://tc39.es/ecma262/#prod-ExpressionBody\n      (node as Undone<N.ArrowFunctionExpression>).body =\n        this.parseMaybeAssign();\n      this.checkParams(node, false, allowExpression, false);\n    } else {\n      const oldStrict = this.state.strict;\n      // Start a new scope with regard to labels\n      // flag (restore them to their old value afterwards).\n      const oldLabels = this.state.labels;\n      this.state.labels = [];\n\n      // FunctionBody[Yield, Await]:\n      //   StatementList[?Yield, ?Await, +Return] opt\n      this.prodParam.enter(this.prodParam.currentFlags() | PARAM_RETURN);\n      node.body = this.parseBlock(\n        true,\n        false,\n        // Strict mode function checks after we parse the statements in the function body.\n        (hasStrictModeDirective: boolean) => {\n          const nonSimple = !this.isSimpleParamList(node.params);\n\n          if (hasStrictModeDirective && nonSimple) {\n            // This logic is here to align the error location with the ESTree plugin.\n            this.raise(Errors.IllegalLanguageModeDirective, {\n              at:\n                // @ts-expect-error kind may not index node\n                (node.kind === \"method\" || node.kind === \"constructor\") &&\n                // @ts-expect-error key may not index node\n                !!node.key\n                  ? // @ts-expect-error node.key has been guarded\n                    node.key.loc.end\n                  : node,\n            });\n          }\n\n          const strictModeChanged = !oldStrict && this.state.strict;\n\n          // Add the params to varDeclaredNames to ensure that an error is thrown\n          // if a let/const declaration in the function clashes with one of the params.\n          this.checkParams(\n            node,\n            !this.state.strict && !allowExpression && !isMethod && !nonSimple,\n            allowExpression,\n            strictModeChanged,\n          );\n\n          // Ensure the function name isn't a forbidden identifier in strict mode, e.g. 'eval'\n          if (this.state.strict && node.id) {\n            this.checkIdentifier(node.id, BIND_OUTSIDE, strictModeChanged);\n          }\n        },\n      );\n      this.prodParam.exit();\n      this.state.labels = oldLabels;\n    }\n    this.expressionScope.exit();\n  }\n\n  isSimpleParameter(node: N.Pattern | N.TSParameterProperty) {\n    return node.type === \"Identifier\";\n  }\n\n  isSimpleParamList(\n    params: ReadonlyArray<N.Pattern | N.TSParameterProperty>,\n  ): boolean {\n    for (let i = 0, len = params.length; i < len; i++) {\n      if (!this.isSimpleParameter(params[i])) return false;\n    }\n    return true;\n  }\n\n  checkParams(\n    node: Undone<N.Function>,\n    allowDuplicates: boolean,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    isArrowFunction?: boolean | null,\n    strictModeChanged: boolean = true,\n  ): void {\n    const checkClashes = !allowDuplicates && new Set<string>();\n    // We create a fake node with the \"ephemeral\" type `FormalParameters`[1]\n    // since we just store an array of parameters. Perhaps someday we can have\n    // something like class FormalParameters extends Array { ... }, which would\n    // also be helpful when traversing this node.\n    //\n    // 1. https://tc39.es/ecma262/#prod-FormalParameters\n    const formalParameters = { type: \"FormalParameters\" } as const;\n    for (const param of node.params) {\n      this.checkLVal(param, {\n        in: formalParameters,\n        binding: BIND_VAR,\n        checkClashes,\n        strictModeChanged,\n      });\n    }\n  }\n\n  // Parses a comma-separated list of expressions, and returns them as\n  // an array. `close` is the token type that ends the list, and\n  // `allowEmpty` can be turned on to allow subsequent commas with\n  // nothing in between them to be parsed as `null` (which is needed\n  // for array literals).\n\n  parseExprList(\n    this: Parser,\n    close: TokenType,\n    allowEmpty?: boolean,\n    refExpressionErrors?: ExpressionErrors | null,\n    nodeForExtra?: N.Node | null,\n  ): (N.Expression | null)[] {\n    const elts: (N.Expression | null)[] = [];\n    let first = true;\n\n    while (!this.eat(close)) {\n      if (first) {\n        first = false;\n      } else {\n        this.expect(tt.comma);\n        if (this.match(close)) {\n          if (nodeForExtra) {\n            this.addTrailingCommaExtraToNode(nodeForExtra);\n          }\n          this.next();\n          break;\n        }\n      }\n\n      elts.push(this.parseExprListItem(allowEmpty, refExpressionErrors));\n    }\n    return elts;\n  }\n\n  parseExprListItem(\n    this: Parser,\n    allowEmpty?: boolean,\n    refExpressionErrors?: ExpressionErrors | null,\n    allowPlaceholder?: boolean | null,\n  ): N.Expression | null;\n  parseExprListItem(\n    this: Parser,\n    allowEmpty?: false,\n    refExpressionErrors?: ExpressionErrors | null,\n    allowPlaceholder?: boolean | null,\n  ): N.Expression;\n  parseExprListItem(\n    this: Parser,\n    allowEmpty?: boolean | null,\n    refExpressionErrors?: ExpressionErrors | null,\n    allowPlaceholder?: boolean | null,\n  ): N.Expression | null {\n    let elt;\n    if (this.match(tt.comma)) {\n      if (!allowEmpty) {\n        this.raise(Errors.UnexpectedToken, {\n          at: this.state.curPosition(),\n          unexpected: \",\",\n        });\n      }\n      elt = null;\n    } else if (this.match(tt.ellipsis)) {\n      const spreadNodeStartLoc = this.state.startLoc;\n\n      elt = this.parseParenItem(\n        this.parseSpread(refExpressionErrors),\n        spreadNodeStartLoc,\n      );\n    } else if (this.match(tt.question)) {\n      this.expectPlugin(\"partialApplication\");\n      if (!allowPlaceholder) {\n        this.raise(Errors.UnexpectedArgumentPlaceholder, {\n          at: this.state.startLoc,\n        });\n      }\n      const node = this.startNode();\n      this.next();\n      elt = this.finishNode(node, \"ArgumentPlaceholder\");\n    } else {\n      elt = this.parseMaybeAssignAllowIn(\n        refExpressionErrors,\n        this.parseParenItem,\n      );\n    }\n    return elt;\n  }\n\n  // Parse the next token as an identifier. If `liberal` is true (used\n  // when parsing properties), it will also convert keywords into\n  // identifiers.\n  // This shouldn't be used to parse the keywords of meta properties, since they\n  // are not identifiers and cannot contain escape sequences.\n\n  parseIdentifier(liberal?: boolean): N.Identifier {\n    const node = this.startNode<N.Identifier>();\n    const name = this.parseIdentifierName(liberal);\n\n    return this.createIdentifier(node, name);\n  }\n\n  createIdentifier(\n    node: Omit<N.Identifier, \"type\">,\n    name: string,\n  ): N.Identifier {\n    node.name = name;\n    node.loc.identifierName = name;\n\n    return this.finishNode(node, \"Identifier\");\n  }\n\n  parseIdentifierName(liberal?: boolean): string {\n    let name: string;\n\n    const { startLoc, type } = this.state;\n\n    if (tokenIsKeywordOrIdentifier(type)) {\n      name = this.state.value;\n    } else {\n      this.unexpected();\n    }\n\n    const tokenIsKeyword = tokenKeywordOrIdentifierIsKeyword(type);\n\n    if (liberal) {\n      // If the current token is not used as a keyword, set its type to \"tt.name\".\n      // This will prevent this.next() from throwing about unexpected escapes.\n      if (tokenIsKeyword) {\n        this.replaceToken(tt.name);\n      }\n    } else {\n      this.checkReservedWord(name, startLoc, tokenIsKeyword, false);\n    }\n\n    this.next();\n\n    return name;\n  }\n\n  checkReservedWord(\n    word: string,\n    startLoc: Position,\n    checkKeywords: boolean,\n    isBinding: boolean,\n  ): void {\n    // Every JavaScript reserved word is 10 characters or less.\n    if (word.length > 10) {\n      return;\n    }\n    // Most identifiers are not reservedWord-like, they don't need special\n    // treatments afterward, which very likely ends up throwing errors\n    if (!canBeReservedWord(word)) {\n      return;\n    }\n\n    if (checkKeywords && isKeyword(word)) {\n      this.raise(Errors.UnexpectedKeyword, {\n        at: startLoc,\n        keyword: word,\n      });\n      return;\n    }\n\n    const reservedTest = !this.state.strict\n      ? isReservedWord\n      : isBinding\n      ? isStrictBindReservedWord\n      : isStrictReservedWord;\n\n    if (reservedTest(word, this.inModule)) {\n      this.raise(Errors.UnexpectedReservedWord, {\n        at: startLoc,\n        reservedWord: word,\n      });\n      return;\n    } else if (word === \"yield\") {\n      if (this.prodParam.hasYield) {\n        this.raise(Errors.YieldBindingIdentifier, { at: startLoc });\n        return;\n      }\n    } else if (word === \"await\") {\n      if (this.prodParam.hasAwait) {\n        this.raise(Errors.AwaitBindingIdentifier, { at: startLoc });\n        return;\n      }\n\n      if (this.scope.inStaticBlock) {\n        this.raise(Errors.AwaitBindingIdentifierInStaticBlock, {\n          at: startLoc,\n        });\n        return;\n      }\n\n      this.expressionScope.recordAsyncArrowParametersError({ at: startLoc });\n    } else if (word === \"arguments\") {\n      if (this.scope.inClassAndNotInNonArrowFunction) {\n        this.raise(Errors.ArgumentsInClass, { at: startLoc });\n        return;\n      }\n    }\n  }\n\n  isAwaitAllowed(): boolean {\n    if (this.prodParam.hasAwait) return true;\n    if (this.options.allowAwaitOutsideFunction && !this.scope.inFunction) {\n      return true;\n    }\n    return false;\n  }\n\n  // Parses await expression inside async function.\n\n  parseAwait(this: Parser, startLoc: Position): N.AwaitExpression {\n    const node = this.startNodeAt<N.AwaitExpression>(startLoc);\n\n    this.expressionScope.recordParameterInitializerError(\n      Errors.AwaitExpressionFormalParameter,\n      {\n        // @ts-expect-error todo(flow->ts)\n        at: node,\n      },\n    );\n\n    if (this.eat(tt.star)) {\n      this.raise(Errors.ObsoleteAwaitStar, { at: node });\n    }\n\n    if (!this.scope.inFunction && !this.options.allowAwaitOutsideFunction) {\n      if (this.isAmbiguousAwait()) {\n        this.ambiguousScriptDifferentAst = true;\n      } else {\n        this.sawUnambiguousESM = true;\n      }\n    }\n\n    if (!this.state.soloAwait) {\n      node.argument = this.parseMaybeUnary(null, true);\n    }\n\n    return this.finishNode(node, \"AwaitExpression\");\n  }\n\n  isAmbiguousAwait(): boolean {\n    if (this.hasPrecedingLineBreak()) return true;\n    const { type } = this.state;\n    return (\n      // All the following expressions are ambiguous:\n      //   await + 0, await - 0, await ( 0 ), await [ 0 ], await / 0 /u, await ``, await of []\n      type === tt.plusMin ||\n      type === tt.parenL ||\n      type === tt.bracketL ||\n      tokenIsTemplate(type) ||\n      (type === tt._of && !this.state.containsEsc) ||\n      // Sometimes the tokenizer generates tt.slash for regexps, and this is\n      // handler by parseExprAtom\n      type === tt.regexp ||\n      type === tt.slash ||\n      // This code could be parsed both as a modulo operator or as an intrinsic:\n      //   await %x(0)\n      (this.hasPlugin(\"v8intrinsic\") && type === tt.modulo)\n    );\n  }\n\n  // Parses yield expression inside generator.\n\n  parseYield(this: Parser): N.YieldExpression {\n    const node = this.startNode<N.YieldExpression>();\n\n    this.expressionScope.recordParameterInitializerError(\n      Errors.YieldInParameter,\n      {\n        // @ts-expect-error todo(flow->ts)\n        at: node,\n      },\n    );\n\n    this.next();\n    let delegating = false;\n    let argument: N.Expression | null = null;\n    if (!this.hasPrecedingLineBreak()) {\n      delegating = this.eat(tt.star);\n      switch (this.state.type) {\n        case tt.semi:\n        case tt.eof:\n        case tt.braceR:\n        case tt.parenR:\n        case tt.bracketR:\n        case tt.braceBarR:\n        case tt.colon:\n        case tt.comma:\n          // The above is the complete set of tokens that can\n          // follow an AssignmentExpression, and none of them\n          // can start an AssignmentExpression\n          if (!delegating) break;\n        /* fallthrough */\n        default:\n          argument = this.parseMaybeAssign();\n      }\n    }\n    node.delegate = delegating;\n    node.argument = argument;\n    return this.finishNode(node, \"YieldExpression\");\n  }\n\n  // Validates a pipeline (for any of the pipeline Babylon plugins) at the point\n  // of the infix operator `|>`.\n\n  checkPipelineAtInfixOperator(left: N.Expression, leftStartLoc: Position) {\n    if (this.hasPlugin([\"pipelineOperator\", { proposal: \"smart\" }])) {\n      if (left.type === \"SequenceExpression\") {\n        // Ensure that the pipeline head is not a comma-delimited\n        // sequence expression.\n        this.raise(Errors.PipelineHeadSequenceExpression, {\n          at: leftStartLoc,\n        });\n      }\n    }\n  }\n\n  parseSmartPipelineBodyInStyle(childExpr: N.Expression, startLoc: Position) {\n    if (this.isSimpleReference(childExpr)) {\n      const bodyNode = this.startNodeAt<N.PipelineBareFunction>(startLoc);\n      bodyNode.callee = childExpr;\n      return this.finishNode(bodyNode, \"PipelineBareFunction\");\n    } else {\n      const bodyNode = this.startNodeAt<N.PipelineTopicExpression>(startLoc);\n      this.checkSmartPipeTopicBodyEarlyErrors(startLoc);\n      bodyNode.expression = childExpr;\n      return this.finishNode(bodyNode, \"PipelineTopicExpression\");\n    }\n  }\n\n  isSimpleReference(expression: N.Expression): boolean {\n    switch (expression.type) {\n      case \"MemberExpression\":\n        return (\n          !expression.computed && this.isSimpleReference(expression.object)\n        );\n      case \"Identifier\":\n        return true;\n      default:\n        return false;\n    }\n  }\n\n  // This helper method is to be called immediately\n  // after a topic-style smart-mix pipe body is parsed.\n  // The `startLoc` is the starting position of the pipe body.\n\n  checkSmartPipeTopicBodyEarlyErrors(startLoc: Position): void {\n    // If the following token is invalidly `=>`, then throw a human-friendly error\n    // instead of something like 'Unexpected token, expected \";\"'.\n    // For example, `x => x |> y => #` (assuming `#` is the topic reference)\n    // groups into `x => (x |> y) => #`,\n    // and `(x |> y) => #` is an invalid arrow function.\n    // This is because smart-mix `|>` has tighter precedence than `=>`.\n    if (this.match(tt.arrow)) {\n      throw this.raise(Errors.PipelineBodyNoArrow, { at: this.state.startLoc });\n    }\n\n    // A topic-style smart-mix pipe body must use the topic reference at least once.\n    if (!this.topicReferenceWasUsedInCurrentContext()) {\n      this.raise(Errors.PipelineTopicUnused, { at: startLoc });\n    }\n  }\n\n  // Enable topic references from outer contexts within Hack-style pipe bodies.\n  // The function modifies the parser's topic-context state to enable or disable\n  // the use of topic references.\n  // The function then calls a callback, then resets the parser\n  // to the old topic-context state that it had before the function was called.\n\n  withTopicBindingContext<T>(callback: () => T): T {\n    const outerContextTopicState = this.state.topicContext;\n    this.state.topicContext = {\n      // Enable the use of the primary topic reference.\n      maxNumOfResolvableTopics: 1,\n      // Hide the use of any topic references from outer contexts.\n      maxTopicIndex: null,\n    };\n\n    try {\n      return callback();\n    } finally {\n      this.state.topicContext = outerContextTopicState;\n    }\n  }\n\n  // This helper method is used only with the deprecated smart-mix pipe proposal.\n  // Disables topic references from outer contexts within syntax constructs\n  // such as the bodies of iteration statements.\n  // The function modifies the parser's topic-context state to enable or disable\n  // the use of topic references with the smartPipelines plugin. They then run a\n  // callback, then they reset the parser to the old topic-context state that it\n  // had before the function was called.\n\n  withSmartMixTopicForbiddingContext<T>(callback: () => T): T {\n    if (this.hasPlugin([\"pipelineOperator\", { proposal: \"smart\" }])) {\n      // Reset the parser’s topic context only if the smart-mix pipe proposal is active.\n      const outerContextTopicState = this.state.topicContext;\n      this.state.topicContext = {\n        // Disable the use of the primary topic reference.\n        maxNumOfResolvableTopics: 0,\n        // Hide the use of any topic references from outer contexts.\n        maxTopicIndex: null,\n      };\n\n      try {\n        return callback();\n      } finally {\n        this.state.topicContext = outerContextTopicState;\n      }\n    } else {\n      // If the pipe proposal is \"minimal\", \"fsharp\", or \"hack\",\n      // or if no pipe proposal is active,\n      // then the callback result is returned\n      // without touching any extra parser state.\n      return callback();\n    }\n  }\n\n  withSoloAwaitPermittingContext<T>(callback: () => T): T {\n    const outerContextSoloAwaitState = this.state.soloAwait;\n    this.state.soloAwait = true;\n\n    try {\n      return callback();\n    } finally {\n      this.state.soloAwait = outerContextSoloAwaitState;\n    }\n  }\n\n  allowInAnd<T>(callback: () => T): T {\n    const flags = this.prodParam.currentFlags();\n    const prodParamToSet = PARAM_IN & ~flags;\n    if (prodParamToSet) {\n      this.prodParam.enter(flags | PARAM_IN);\n      try {\n        return callback();\n      } finally {\n        this.prodParam.exit();\n      }\n    }\n    return callback();\n  }\n\n  disallowInAnd<T>(callback: () => T): T {\n    const flags = this.prodParam.currentFlags();\n    const prodParamToClear = PARAM_IN & flags;\n    if (prodParamToClear) {\n      this.prodParam.enter(flags & ~PARAM_IN);\n      try {\n        return callback();\n      } finally {\n        this.prodParam.exit();\n      }\n    }\n    return callback();\n  }\n\n  // Register the use of a topic reference within the current\n  // topic-binding context.\n  registerTopicReference(): void {\n    this.state.topicContext.maxTopicIndex = 0;\n  }\n\n  topicReferenceIsAllowedInCurrentContext(): boolean {\n    return this.state.topicContext.maxNumOfResolvableTopics >= 1;\n  }\n\n  topicReferenceWasUsedInCurrentContext(): boolean {\n    return (\n      this.state.topicContext.maxTopicIndex != null &&\n      this.state.topicContext.maxTopicIndex >= 0\n    );\n  }\n\n  parseFSharpPipelineBody(this: Parser, prec: number): N.Expression {\n    const startLoc = this.state.startLoc;\n\n    this.state.potentialArrowAt = this.state.start;\n    const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;\n    this.state.inFSharpPipelineDirectBody = true;\n\n    const ret = this.parseExprOp(\n      this.parseMaybeUnaryOrPrivate(),\n      startLoc,\n      prec,\n    );\n\n    this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;\n\n    return ret;\n  }\n\n  // https://github.com/tc39/proposal-js-module-blocks\n  parseModuleExpression(this: Parser): N.ModuleExpression {\n    this.expectPlugin(\"moduleBlocks\");\n    const node = this.startNode<N.ModuleExpression>();\n    this.next(); // eat \"module\"\n    if (!this.match(tt.braceL)) {\n      this.unexpected(null, tt.braceL);\n    }\n    // start program node immediately after `{`\n    const program = this.startNodeAt<N.Program>(this.state.endLoc);\n    this.next(); // eat `{`\n\n    const revertScopes = this.initializeScopes(/** inModule */ true);\n    this.enterInitialScopes();\n\n    try {\n      node.body = this.parseProgram(program, tt.braceR, \"module\");\n    } finally {\n      revertScopes();\n    }\n    return this.finishNode<N.ModuleExpression>(node, \"ModuleExpression\");\n  }\n\n  // Used in Flow plugin\n  parsePropertyNamePrefixOperator(\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    prop: Undone<N.ObjectOrClassMember | N.ClassMember>,\n  ): void {}\n}\n"],"mappings":"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"}������������������������������������������������������������������������������������������lib/parser/index.js���������������������������������������������������������������������������������0000644�����������������00000002222�15120211212�0010234 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;
var _options = require("../options");
var _statement = require("./statement");
var _scope = require("../util/scope");
class Parser extends _statement.default {
  constructor(options, input) {
    options = (0, _options.getOptions)(options);
    super(options, input);
    this.options = options;
    this.initializeScopes();
    this.plugins = pluginsMap(this.options.plugins);
    this.filename = options.sourceFilename;
  }
  getScopeHandler() {
    return _scope.default;
  }
  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;
  }
}
exports.default = Parser;
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;
}

//# sourceMappingURL=index.js.map
������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������lib/parser/index.js.map�����������������������������������������������������������������������������0000644�����������������00000006631�15120211212�0011020 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������{"version":3,"names":["_options","require","_statement","_scope","Parser","StatementParser","constructor","options","input","getOptions","initializeScopes","plugins","pluginsMap","filename","sourceFilename","getScopeHandler","ScopeHandler","parse","enterInitialScopes","file","startNode","program","nextToken","errors","parseTopLevel","state","exports","default","pluginMap","Map","plugin","name","Array","isArray","has","set"],"sources":["../../src/parser/index.ts"],"sourcesContent":["import type { Options } from \"../options\";\nimport type * as N from \"../types\";\nimport type { PluginList } from \"../plugin-utils\";\nimport { getOptions } from \"../options\";\nimport StatementParser from \"./statement\";\nimport ScopeHandler from \"../util/scope\";\n\nexport type PluginsMap = Map<\n  string,\n  {\n    [x: string]: any;\n  }\n>;\n\nexport default class Parser extends StatementParser {\n  // Forward-declaration so typescript plugin can override jsx plugin\n  // todo(flow->ts) - this probably can be removed\n  // abstract jsxParseOpeningElementAfterName(\n  //   node: N.JSXOpeningElement,\n  // ): N.JSXOpeningElement;\n\n  constructor(options: Options | undefined | null, input: string) {\n    options = getOptions(options);\n    super(options, input);\n\n    this.options = options;\n    this.initializeScopes();\n    this.plugins = pluginsMap(this.options.plugins);\n    this.filename = options.sourceFilename;\n  }\n\n  // This can be overwritten, for example, by the TypeScript plugin.\n  getScopeHandler(): {\n    new (...args: any): ScopeHandler;\n  } {\n    return ScopeHandler;\n  }\n\n  parse(): N.File {\n    this.enterInitialScopes();\n    const file = this.startNode() as N.File;\n    const program = this.startNode() as N.Program;\n    this.nextToken();\n    file.errors = null;\n    this.parseTopLevel(file, program);\n    file.errors = this.state.errors;\n    return file;\n  }\n}\n\nfunction pluginsMap(plugins: PluginList): PluginsMap {\n  const pluginMap: PluginsMap = new Map();\n  for (const plugin of plugins) {\n    const [name, options] = Array.isArray(plugin) ? plugin : [plugin, {}];\n    if (!pluginMap.has(name)) pluginMap.set(name, options || {});\n  }\n  return pluginMap;\n}\n"],"mappings":";;;;;;AAGA,IAAAA,QAAA,GAAAC,OAAA;AACA,IAAAC,UAAA,GAAAD,OAAA;AACA,IAAAE,MAAA,GAAAF,OAAA;AASe,MAAMG,MAAM,SAASC,kBAAe,CAAC;EAOlDC,WAAWA,CAACC,OAAmC,EAAEC,KAAa,EAAE;IAC9DD,OAAO,GAAG,IAAAE,mBAAU,EAACF,OAAO,CAAC;IAC7B,KAAK,CAACA,OAAO,EAAEC,KAAK,CAAC;IAErB,IAAI,CAACD,OAAO,GAAGA,OAAO;IACtB,IAAI,CAACG,gBAAgB,CAAC,CAAC;IACvB,IAAI,CAACC,OAAO,GAAGC,UAAU,CAAC,IAAI,CAACL,OAAO,CAACI,OAAO,CAAC;IAC/C,IAAI,CAACE,QAAQ,GAAGN,OAAO,CAACO,cAAc;EACxC;EAGAC,eAAeA,CAAA,EAEb;IACA,OAAOC,cAAY;EACrB;EAEAC,KAAKA,CAAA,EAAW;IACd,IAAI,CAACC,kBAAkB,CAAC,CAAC;IACzB,MAAMC,IAAI,GAAG,IAAI,CAACC,SAAS,CAAC,CAAW;IACvC,MAAMC,OAAO,GAAG,IAAI,CAACD,SAAS,CAAC,CAAc;IAC7C,IAAI,CAACE,SAAS,CAAC,CAAC;IAChBH,IAAI,CAACI,MAAM,GAAG,IAAI;IAClB,IAAI,CAACC,aAAa,CAACL,IAAI,EAAEE,OAAO,CAAC;IACjCF,IAAI,CAACI,MAAM,GAAG,IAAI,CAACE,KAAK,CAACF,MAAM;IAC/B,OAAOJ,IAAI;EACb;AACF;AAACO,OAAA,CAAAC,OAAA,GAAAvB,MAAA;AAED,SAASQ,UAAUA,CAACD,OAAmB,EAAc;EACnD,MAAMiB,SAAqB,GAAG,IAAIC,GAAG,CAAC,CAAC;EACvC,KAAK,MAAMC,MAAM,IAAInB,OAAO,EAAE;IAC5B,MAAM,CAACoB,IAAI,EAAExB,OAAO,CAAC,GAAGyB,KAAK,CAACC,OAAO,CAACH,MAAM,CAAC,GAAGA,MAAM,GAAG,CAACA,MAAM,EAAE,CAAC,CAAC,CAAC;IACrE,IAAI,CAACF,SAAS,CAACM,GAAG,CAACH,IAAI,CAAC,EAAEH,SAAS,CAACO,GAAG,CAACJ,IAAI,EAAExB,OAAO,IAAI,CAAC,CAAC,CAAC;EAC9D;EACA,OAAOqB,SAAS;AAClB"}�������������������������������������������������������������������������������������������������������lib/parser/lval.js����������������������������������������������������������������������������������0000644�����������������00000033312�15120211212�0010067 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = exports.ParseBindingListFlags = void 0;
var _types = require("../tokenizer/types");
var _identifier = require("../util/identifier");
var _node = require("./node");
var _scopeflags = require("../util/scopeflags");
var _parseError = require("../parse-error");
const getOwn = (object, key) => Object.hasOwnProperty.call(object, key) && object[key];
const unwrapParenthesizedExpression = node => {
  return node.type === "ParenthesizedExpression" ? unwrapParenthesizedExpression(node.expression) : node;
};
var ParseBindingListFlags = {
  ALLOW_EMPTY: 1,
  IS_FUNCTION_PARAMS: 2,
  IS_CONSTRUCTOR_PARAMS: 4
};
exports.ParseBindingListFlags = ParseBindingListFlags;
class LValParser extends _node.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.recordArrowParameterBindingError(_parseError.Errors.InvalidParenthesizedAssignment, {
            at: node
          });
        } else if (parenthesized.type !== "MemberExpression") {
          this.raise(_parseError.Errors.InvalidParenthesizedAssignment, {
            at: node
          });
        }
      } else {
        this.raise(_parseError.Errors.InvalidParenthesizedAssignment, {
          at: 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(_parseError.Errors.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":
        {
          throw new Error("Internal @babel/parser error (this is a bug, please report it)." + " SpreadElement should be converted by .toAssignable's caller.");
        }
      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(_parseError.Errors.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;
      default:
    }
  }
  toAssignableObjectExpressionProp(prop, isLast, isLHS) {
    if (prop.type === "ObjectMethod") {
      this.raise(prop.kind === "get" || prop.kind === "set" ? _parseError.Errors.PatternHasAccessor : _parseError.Errors.PatternHasMethod, {
        at: prop.key
      });
    } else if (prop.type === "SpreadElement") {
      prop.type = "RestElement";
      const arg = prop.argument;
      this.checkToRestConversion(arg, false);
      this.toAssignable(arg, isLHS);
      if (!isLast) {
        this.raise(_parseError.Errors.RestTrailingComma, {
          at: prop
        });
      }
    } else {
      this.toAssignable(prop, isLHS);
    }
  }
  toAssignableList(exprList, trailingCommaLoc, isLHS) {
    const end = exprList.length - 1;
    for (let i = 0; i <= end; i++) {
      const elt = exprList[i];
      if (!elt) continue;
      if (elt.type === "SpreadElement") {
        elt.type = "RestElement";
        const arg = elt.argument;
        this.checkToRestConversion(arg, true);
        this.toAssignable(arg, isLHS);
      } else {
        this.toAssignable(elt, isLHS);
      }
      if (elt.type === "RestElement") {
        if (i < end) {
          this.raise(_parseError.Errors.RestTrailingComma, {
            at: elt
          });
        } else if (trailingCommaLoc) {
          this.raise(_parseError.Errors.RestTrailingComma, {
            at: trailingCommaLoc
          });
        }
      }
    }
  }
  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) {
    const node = this.startNode();
    this.next();
    node.argument = this.parseMaybeAssignAllowIn(refExpressionErrors, undefined);
    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, ParseBindingListFlags.ALLOW_EMPTY);
          return this.finishNode(node, "ArrayPattern");
        }
      case 5:
        return this.parseObjectLike(8, true);
    }
    return this.parseIdentifier();
  }
  parseBindingList(close, closeCharCode, flags) {
    const allowEmpty = flags & ParseBindingListFlags.ALLOW_EMPTY;
    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(), flags));
        if (!this.checkCommaAfterRest(closeCharCode)) {
          this.expect(close);
          break;
        }
      } else {
        const decorators = [];
        if (this.match(26) && this.hasPlugin("decorators")) {
          this.raise(_parseError.Errors.UnsupportedParameterDecorator, {
            at: this.state.startLoc
          });
        }
        while (this.match(26)) {
          decorators.push(this.parseDecorator());
        }
        elts.push(this.parseAssignableListItem(flags, 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,
      startLoc
    } = this.state;
    if (type === 21) {
      return this.parseBindingRestProperty(prop);
    } else if (type === 136) {
      this.expectPlugin("destructuringPrivate", startLoc);
      this.classScope.usePrivateName(this.state.value, startLoc);
      prop.key = this.parsePrivateName();
    } else {
      this.parsePropertyName(prop);
    }
    prop.method = false;
    return this.parseObjPropValue(prop, startLoc, false, false, true, false);
  }
  parseAssignableListItem(flags, decorators) {
    const left = this.parseMaybeDefault();
    this.parseAssignableListItemTypes(left, flags);
    const elt = this.parseMaybeDefault(left.loc.start, left);
    if (decorators.length) {
      left.decorators = decorators;
    }
    return elt;
  }
  parseAssignableListItemTypes(param, flags) {
    return param;
  }
  parseMaybeDefault(startLoc, left) {
    var _startLoc, _left;
    (_startLoc = startLoc) != null ? _startLoc : startLoc = this.state.startLoc;
    left = (_left = left) != null ? _left : this.parseBindingAtom();
    if (!this.eat(29)) return left;
    const node = this.startNodeAt(startLoc);
    node.left = left;
    node.right = this.parseMaybeAssignAllowIn();
    return this.finishNode(node, "AssignmentPattern");
  }
  isValidLVal(type, isUnparenthesizedInAssign, binding) {
    return getOwn({
      AssignmentPattern: "left",
      RestElement: "argument",
      ObjectProperty: "value",
      ParenthesizedExpression: "expression",
      ArrayPattern: "elements",
      ObjectPattern: "properties"
    }, type);
  }
  checkLVal(expression, {
    in: ancestor,
    binding = _scopeflags.BIND_NONE,
    checkClashes = false,
    strictModeChanged = false,
    hasParenthesizedAncestor = false
  }) {
    var _expression$extra;
    const type = expression.type;
    if (this.isObjectMethod(expression)) return;
    if (type === "MemberExpression") {
      if (binding !== _scopeflags.BIND_NONE) {
        this.raise(_parseError.Errors.InvalidPropertyBindingPattern, {
          at: expression
        });
      }
      return;
    }
    if (type === "Identifier") {
      this.checkIdentifier(expression, binding, strictModeChanged);
      const {
        name
      } = expression;
      if (checkClashes) {
        if (checkClashes.has(name)) {
          this.raise(_parseError.Errors.ParamDupe, {
            at: expression
          });
        } else {
          checkClashes.add(name);
        }
      }
      return;
    }
    const validity = this.isValidLVal(type, !(hasParenthesizedAncestor || (_expression$extra = expression.extra) != null && _expression$extra.parenthesized) && ancestor.type === "AssignmentExpression", binding);
    if (validity === true) return;
    if (validity === false) {
      const ParseErrorClass = binding === _scopeflags.BIND_NONE ? _parseError.Errors.InvalidLhs : _parseError.Errors.InvalidLhsBinding;
      this.raise(ParseErrorClass, {
        at: expression,
        ancestor
      });
      return;
    }
    const [key, isParenthesizedExpression] = Array.isArray(validity) ? validity : [validity, type === "ParenthesizedExpression"];
    const nextAncestor = type === "ArrayPattern" || type === "ObjectPattern" || type === "ParenthesizedExpression" ? {
      type
    } : ancestor;
    for (const child of [].concat(expression[key])) {
      if (child) {
        this.checkLVal(child, {
          in: nextAncestor,
          binding,
          checkClashes,
          strictModeChanged,
          hasParenthesizedAncestor: isParenthesizedExpression
        });
      }
    }
  }
  checkIdentifier(at, bindingType, strictModeChanged = false) {
    if (this.state.strict && (strictModeChanged ? (0, _identifier.isStrictBindReservedWord)(at.name, this.inModule) : (0, _identifier.isStrictBindOnlyReservedWord)(at.name))) {
      if (bindingType === _scopeflags.BIND_NONE) {
        this.raise(_parseError.Errors.StrictEvalArguments, {
          at,
          referenceName: at.name
        });
      } else {
        this.raise(_parseError.Errors.StrictEvalArgumentsBinding, {
          at,
          bindingName: at.name
        });
      }
    }
    if (bindingType & _scopeflags.BIND_FLAGS_NO_LET_IN_LEXICAL && at.name === "let") {
      this.raise(_parseError.Errors.LetInLexicalBinding, {
        at
      });
    }
    if (!(bindingType & _scopeflags.BIND_NONE)) {
      this.declareNameFromIdentifier(at, bindingType);
    }
  }
  declareNameFromIdentifier(identifier, binding) {
    this.scope.declareName(identifier.name, binding, identifier.loc.start);
  }
  checkToRestConversion(node, allowPattern) {
    switch (node.type) {
      case "ParenthesizedExpression":
        this.checkToRestConversion(node.expression, allowPattern);
        break;
      case "Identifier":
      case "MemberExpression":
        break;
      case "ArrayExpression":
      case "ObjectExpression":
        if (allowPattern) break;
      default:
        this.raise(_parseError.Errors.InvalidRestAssignmentPattern, {
          at: node
        });
    }
  }
  checkCommaAfterRest(close) {
    if (!this.match(12)) {
      return false;
    }
    this.raise(this.lookaheadCharCode() === close ? _parseError.Errors.RestTrailingComma : _parseError.Errors.ElementAfterRest, {
      at: this.state.startLoc
    });
    return true;
  }
}
exports.default = LValParser;

//# sourceMappingURL=lval.js.map
����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������lib/parser/lval.js.map������������������������������������������������������������������������������0000644�����������������00000116500�15120211212�0010644 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������{"version":3,"names":["_types","require","_identifier","_node","_scopeflags","_parseError","getOwn","object","key","Object","hasOwnProperty","call","unwrapParenthesizedExpression","node","type","expression","ParseBindingListFlags","ALLOW_EMPTY","IS_FUNCTION_PARAMS","IS_CONSTRUCTOR_PARAMS","exports","LValParser","NodeUtils","toAssignable","isLHS","_node$extra","_node$extra3","parenthesized","undefined","extra","expressionScope","recordArrowParameterBindingError","Errors","InvalidParenthesizedAssignment","at","raise","i","length","properties","last","_node$extra2","prop","isLast","toAssignableObjectExpressionProp","trailingCommaLoc","RestTrailingComma","value","isPrivateName","classScope","usePrivateName","getPrivateNameSV","loc","start","Error","toAssignableList","elements","operator","MissingEqInAssignment","left","end","kind","PatternHasAccessor","PatternHasMethod","arg","argument","checkToRestConversion","exprList","elt","isAssignable","isBinding","every","element","toReferencedList","isParenthesizedExpr","toReferencedListDeep","expr","parseSpread","refExpressionErrors","startNode","next","parseMaybeAssignAllowIn","finishNode","parseRestBinding","parseBindingAtom","state","parseBindingList","parseObjectLike","parseIdentifier","close","closeCharCode","flags","allowEmpty","elts","first","eat","expect","match","push","parseAssignableListItemTypes","checkCommaAfterRest","decorators","hasPlugin","UnsupportedParameterDecorator","startLoc","parseDecorator","parseAssignableListItem","parseBindingRestProperty","parseBindingProperty","expectPlugin","parsePrivateName","parsePropertyName","method","parseObjPropValue","parseMaybeDefault","param","_startLoc","_left","startNodeAt","right","isValidLVal","isUnparenthesizedInAssign","binding","AssignmentPattern","RestElement","ObjectProperty","ParenthesizedExpression","ArrayPattern","ObjectPattern","checkLVal","in","ancestor","BIND_NONE","checkClashes","strictModeChanged","hasParenthesizedAncestor","_expression$extra","isObjectMethod","InvalidPropertyBindingPattern","checkIdentifier","name","has","ParamDupe","add","validity","ParseErrorClass","InvalidLhs","InvalidLhsBinding","isParenthesizedExpression","Array","isArray","nextAncestor","child","concat","bindingType","strict","isStrictBindReservedWord","inModule","isStrictBindOnlyReservedWord","StrictEvalArguments","referenceName","StrictEvalArgumentsBinding","bindingName","BIND_FLAGS_NO_LET_IN_LEXICAL","LetInLexicalBinding","declareNameFromIdentifier","identifier","scope","declareName","allowPattern","InvalidRestAssignmentPattern","lookaheadCharCode","ElementAfterRest","default"],"sources":["../../src/parser/lval.ts"],"sourcesContent":["import * as charCodes from \"charcodes\";\nimport { tt, type TokenType } from \"../tokenizer/types\";\nimport type {\n  AssignmentPattern,\n  TSParameterProperty,\n  Decorator,\n  Expression,\n  Identifier,\n  Node,\n  Pattern,\n  RestElement,\n  SpreadElement,\n  ObjectOrClassMember,\n  ClassMember,\n  ObjectMember,\n  TsNamedTypeElementBase,\n  PrivateName,\n  ObjectExpression,\n  ObjectPattern,\n  ArrayExpression,\n  ArrayPattern,\n} from \"../types\";\nimport type { Pos, Position } from \"../util/location\";\nimport {\n  isStrictBindOnlyReservedWord,\n  isStrictBindReservedWord,\n} from \"../util/identifier\";\nimport { NodeUtils, type Undone } from \"./node\";\nimport {\n  type BindingTypes,\n  BIND_NONE,\n  BIND_FLAGS_NO_LET_IN_LEXICAL,\n} from \"../util/scopeflags\";\nimport type { ExpressionErrors } from \"./util\";\nimport { Errors, type LValAncestor } from \"../parse-error\";\nimport type Parser from \"./index\";\n\nconst getOwn = <T extends {}>(object: T, key: keyof T) =>\n  Object.hasOwnProperty.call(object, key) && object[key];\n\nconst unwrapParenthesizedExpression = (node: Node): Node => {\n  return node.type === \"ParenthesizedExpression\"\n    ? unwrapParenthesizedExpression(node.expression)\n    : node;\n};\n\nexport const enum ParseBindingListFlags {\n  ALLOW_EMPTY = 1 << 0,\n  IS_FUNCTION_PARAMS = 1 << 1,\n  IS_CONSTRUCTOR_PARAMS = 1 << 2,\n}\n\nexport default abstract class LValParser extends NodeUtils {\n  // Forward-declaration: defined in expression.js\n  abstract parseIdentifier(liberal?: boolean): Identifier;\n  abstract parseMaybeAssign(\n    refExpressionErrors?: ExpressionErrors | null,\n    afterLeftParse?: Function,\n    refNeedsArrowPos?: Pos | null,\n  ): Expression;\n\n  abstract parseMaybeAssignAllowIn(\n    refExpressionErrors?: ExpressionErrors | null,\n    afterLeftParse?: Function,\n    refNeedsArrowPos?: Pos | null,\n  ): Expression;\n\n  abstract parseObjectLike<T extends ObjectPattern | ObjectExpression>(\n    close: TokenType,\n    isPattern: boolean,\n    isRecord?: boolean,\n    refExpressionErrors?: ExpressionErrors,\n  ): T;\n  abstract parseObjPropValue(\n    prop: any,\n    startLoc: Position | null,\n    isGenerator: boolean,\n    isAsync: boolean,\n    isPattern: boolean,\n    isAccessor: boolean,\n    refExpressionErrors?: ExpressionErrors | null,\n  ): void;\n  abstract parsePropertyName(\n    prop: ObjectOrClassMember | ClassMember | TsNamedTypeElementBase,\n  ): Expression | Identifier;\n  abstract parsePrivateName(): PrivateName;\n  // Forward-declaration: defined in statement.js\n  abstract parseDecorator(): Decorator;\n\n  /**\n   * Convert existing expression atom to assignable pattern\n   * if possible. Also checks invalid destructuring targets:\n   *\n   * - Parenthesized Destructuring patterns\n   * - RestElement is not the last element\n   * - Missing `=` in assignment pattern\n   *\n   * NOTE: There is a corresponding \"isAssignable\" method.\n   * When this one is updated, please check if also that one needs to be updated.\n   *\n   * @param node The expression atom\n   * @param isLHS Whether we are parsing a LeftHandSideExpression.\n   *              If isLHS is `true`, the following cases are allowed: `[(a)] = [0]`, `[(a.b)] = [0]`\n   *              If isLHS is `false`, we are in an arrow function parameters list.\n   */\n  toAssignable(node: Node, isLHS: boolean = false): void {\n    let parenthesized = undefined;\n    if (node.type === \"ParenthesizedExpression\" || node.extra?.parenthesized) {\n      parenthesized = unwrapParenthesizedExpression(node);\n      if (isLHS) {\n        // an LHS can be reinterpreted to a binding pattern but not vice versa.\n        // therefore a parenthesized identifier is ambiguous until we are sure it is an assignment expression\n        // i.e. `([(a) = []] = []) => {}`\n        // see also `recordArrowParameterBindingError` signature in packages/babel-parser/src/util/expression-scope.js\n        if (parenthesized.type === \"Identifier\") {\n          this.expressionScope.recordArrowParameterBindingError(\n            Errors.InvalidParenthesizedAssignment,\n            { at: node },\n          );\n        } else if (parenthesized.type !== \"MemberExpression\") {\n          // A parenthesized member expression can be in LHS but not in pattern.\n          // If the LHS is later interpreted as a pattern, `checkLVal` will throw for member expression binding\n          // i.e. `([(a.b) = []] = []) => {}`\n          this.raise(Errors.InvalidParenthesizedAssignment, { at: node });\n        }\n      } else {\n        this.raise(Errors.InvalidParenthesizedAssignment, { at: node });\n      }\n    }\n\n    switch (node.type) {\n      case \"Identifier\":\n      case \"ObjectPattern\":\n      case \"ArrayPattern\":\n      case \"AssignmentPattern\":\n      case \"RestElement\":\n        break;\n\n      case \"ObjectExpression\":\n        node.type = \"ObjectPattern\";\n        for (\n          let i = 0, length = node.properties.length, last = length - 1;\n          i < length;\n          i++\n        ) {\n          const prop = node.properties[i];\n          const isLast = i === last;\n          this.toAssignableObjectExpressionProp(prop, isLast, isLHS);\n\n          if (\n            isLast &&\n            prop.type === \"RestElement\" &&\n            node.extra?.trailingCommaLoc\n          ) {\n            this.raise(Errors.RestTrailingComma, {\n              at: node.extra.trailingCommaLoc,\n            });\n          }\n        }\n        break;\n\n      case \"ObjectProperty\": {\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        break;\n      }\n\n      case \"SpreadElement\": {\n        throw new Error(\n          \"Internal @babel/parser error (this is a bug, please report it).\" +\n            \" SpreadElement should be converted by .toAssignable's caller.\",\n        );\n      }\n\n      case \"ArrayExpression\":\n        node.type = \"ArrayPattern\";\n        this.toAssignableList(\n          node.elements,\n          node.extra?.trailingCommaLoc,\n          isLHS,\n        );\n        break;\n\n      case \"AssignmentExpression\":\n        if (node.operator !== \"=\") {\n          this.raise(Errors.MissingEqInAssignment, { at: node.left.loc.end });\n        }\n\n        node.type = \"AssignmentPattern\";\n        delete node.operator;\n        this.toAssignable(node.left, isLHS);\n        break;\n\n      case \"ParenthesizedExpression\":\n        /*::invariant (parenthesized !== undefined) */\n        this.toAssignable(parenthesized, isLHS);\n        break;\n\n      default:\n      // We don't know how to deal with this node. It will\n      // be reported by a later call to checkLVal\n    }\n  }\n\n  toAssignableObjectExpressionProp(\n    prop: Node,\n    isLast: boolean,\n    isLHS: boolean,\n  ) {\n    if (prop.type === \"ObjectMethod\") {\n      this.raise(\n        prop.kind === \"get\" || prop.kind === \"set\"\n          ? Errors.PatternHasAccessor\n          : Errors.PatternHasMethod,\n        { at: prop.key },\n      );\n    } else if (prop.type === \"SpreadElement\") {\n      prop.type = \"RestElement\";\n      const arg = prop.argument;\n      this.checkToRestConversion(arg, /* allowPattern */ false);\n      this.toAssignable(arg, isLHS);\n\n      if (!isLast) {\n        this.raise(Errors.RestTrailingComma, { at: prop });\n      }\n    } else {\n      this.toAssignable(prop, isLHS);\n    }\n  }\n\n  // Convert list of expression atoms to binding list.\n\n  toAssignableList(\n    exprList: Expression[],\n    trailingCommaLoc: Position | undefined | null,\n    isLHS: boolean,\n  ): void {\n    const end = exprList.length - 1;\n\n    for (let i = 0; i <= end; i++) {\n      const elt = exprList[i];\n      if (!elt) continue;\n\n      if (elt.type === \"SpreadElement\") {\n        elt.type = \"RestElement\";\n        const arg = elt.argument;\n        this.checkToRestConversion(arg, /* allowPattern */ true);\n        this.toAssignable(arg, isLHS);\n      } else {\n        this.toAssignable(elt, isLHS);\n      }\n\n      if (elt.type === \"RestElement\") {\n        if (i < end) {\n          this.raise(Errors.RestTrailingComma, { at: elt });\n        } else if (trailingCommaLoc) {\n          this.raise(Errors.RestTrailingComma, { at: trailingCommaLoc });\n        }\n      }\n    }\n  }\n\n  isAssignable(node: Node, isBinding?: boolean): boolean {\n    switch (node.type) {\n      case \"Identifier\":\n      case \"ObjectPattern\":\n      case \"ArrayPattern\":\n      case \"AssignmentPattern\":\n      case \"RestElement\":\n        return true;\n\n      case \"ObjectExpression\": {\n        const last = node.properties.length - 1;\n        return (node.properties as ObjectExpression[\"properties\"]).every(\n          (prop, i) => {\n            return (\n              prop.type !== \"ObjectMethod\" &&\n              (i === last || prop.type !== \"SpreadElement\") &&\n              this.isAssignable(prop)\n            );\n          },\n        );\n      }\n\n      case \"ObjectProperty\":\n        return this.isAssignable(node.value);\n\n      case \"SpreadElement\":\n        return this.isAssignable(node.argument);\n\n      case \"ArrayExpression\":\n        return (node as ArrayExpression).elements.every(\n          element => element === null || this.isAssignable(element),\n        );\n\n      case \"AssignmentExpression\":\n        return node.operator === \"=\";\n\n      case \"ParenthesizedExpression\":\n        return this.isAssignable(node.expression);\n\n      case \"MemberExpression\":\n      case \"OptionalMemberExpression\":\n        return !isBinding;\n\n      default:\n        return false;\n    }\n  }\n\n  // Convert list of expression atoms to a list of\n\n  toReferencedList(\n    exprList: ReadonlyArray<Expression | undefined | null>,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    isParenthesizedExpr?: boolean,\n  ): ReadonlyArray<Expression | undefined | null> {\n    return exprList;\n  }\n\n  toReferencedListDeep(\n    exprList: ReadonlyArray<Expression | undefined | null>,\n    isParenthesizedExpr?: boolean,\n  ): void {\n    this.toReferencedList(exprList, isParenthesizedExpr);\n\n    for (const expr of exprList) {\n      if (expr?.type === \"ArrayExpression\") {\n        this.toReferencedListDeep(expr.elements);\n      }\n    }\n  }\n\n  // Parses spread element.\n\n  parseSpread(\n    this: Parser,\n    refExpressionErrors?: ExpressionErrors | null,\n  ): SpreadElement {\n    const node = this.startNode<SpreadElement>();\n    this.next();\n    node.argument = this.parseMaybeAssignAllowIn(\n      refExpressionErrors,\n      undefined,\n    );\n    return this.finishNode(node, \"SpreadElement\");\n  }\n\n  // https://tc39.es/ecma262/#prod-BindingRestProperty\n  // https://tc39.es/ecma262/#prod-BindingRestElement\n  parseRestBinding(this: Parser): RestElement {\n    const node = this.startNode<RestElement>();\n    this.next(); // eat `...`\n    node.argument = this.parseBindingAtom();\n    return this.finishNode(node, \"RestElement\");\n  }\n\n  // Parses lvalue (assignable) atom.\n  parseBindingAtom(this: Parser): Pattern {\n    // https://tc39.es/ecma262/#prod-BindingPattern\n    switch (this.state.type) {\n      case tt.bracketL: {\n        const node = this.startNode<ArrayPattern>();\n        this.next();\n        // @ts-expect-error: Fixme: TSParameterProperty can not be assigned to node.elements\n        node.elements = this.parseBindingList(\n          tt.bracketR,\n          charCodes.rightSquareBracket,\n          ParseBindingListFlags.ALLOW_EMPTY,\n        );\n        return this.finishNode(node, \"ArrayPattern\");\n      }\n\n      case tt.braceL:\n        return this.parseObjectLike(tt.braceR, true);\n    }\n\n    // https://tc39.es/ecma262/#prod-BindingIdentifier\n    return this.parseIdentifier();\n  }\n\n  // https://tc39.es/ecma262/#prod-BindingElementList\n  parseBindingList(\n    this: Parser,\n    close: TokenType,\n    closeCharCode: (typeof charCodes)[keyof typeof charCodes],\n    flags: ParseBindingListFlags,\n  ): Array<Pattern | TSParameterProperty> {\n    const allowEmpty = flags & ParseBindingListFlags.ALLOW_EMPTY;\n\n    const elts: Array<Pattern | TSParameterProperty> = [];\n    let first = true;\n    while (!this.eat(close)) {\n      if (first) {\n        first = false;\n      } else {\n        this.expect(tt.comma);\n      }\n      if (allowEmpty && this.match(tt.comma)) {\n        elts.push(null);\n      } else if (this.eat(close)) {\n        break;\n      } else if (this.match(tt.ellipsis)) {\n        elts.push(\n          this.parseAssignableListItemTypes(this.parseRestBinding(), flags),\n        );\n        if (!this.checkCommaAfterRest(closeCharCode)) {\n          this.expect(close);\n          break;\n        }\n      } else {\n        const decorators = [];\n        if (this.match(tt.at) && this.hasPlugin(\"decorators\")) {\n          this.raise(Errors.UnsupportedParameterDecorator, {\n            at: this.state.startLoc,\n          });\n        }\n        // invariant: hasPlugin(\"decorators-legacy\")\n        while (this.match(tt.at)) {\n          decorators.push(this.parseDecorator());\n        }\n        elts.push(this.parseAssignableListItem(flags, decorators));\n      }\n    }\n    return elts;\n  }\n\n  // https://tc39.es/ecma262/#prod-BindingRestProperty\n  parseBindingRestProperty(\n    this: Parser,\n    prop: Undone<RestElement>,\n  ): RestElement {\n    this.next(); // eat '...'\n    // Don't use parseRestBinding() as we only allow Identifier here.\n    prop.argument = this.parseIdentifier();\n    this.checkCommaAfterRest(charCodes.rightCurlyBrace);\n    return this.finishNode(prop, \"RestElement\");\n  }\n\n  // https://tc39.es/ecma262/#prod-BindingProperty\n  parseBindingProperty(this: Parser): ObjectMember | RestElement {\n    const prop = this.startNode<ObjectMember | RestElement>();\n    const { type, startLoc } = this.state;\n    if (type === tt.ellipsis) {\n      return this.parseBindingRestProperty(prop as Undone<RestElement>);\n    } else if (type === tt.privateName) {\n      this.expectPlugin(\"destructuringPrivate\", startLoc);\n      this.classScope.usePrivateName(this.state.value, startLoc);\n      (prop as Undone<ObjectMember>).key = this.parsePrivateName();\n    } else {\n      this.parsePropertyName(prop as Undone<ObjectMember>);\n    }\n    (prop as Undone<ObjectMember>).method = false;\n    return this.parseObjPropValue(\n      prop as Undone<ObjectMember>,\n      startLoc,\n      false /* isGenerator */,\n      false /* isAsync */,\n      true /* isPattern */,\n      false /* isAccessor */,\n    );\n  }\n\n  parseAssignableListItem(\n    this: Parser,\n    flags: ParseBindingListFlags,\n    decorators: Decorator[],\n  ): Pattern | TSParameterProperty {\n    const left = this.parseMaybeDefault();\n    this.parseAssignableListItemTypes(left, flags);\n    const elt = this.parseMaybeDefault(left.loc.start, left);\n    if (decorators.length) {\n      left.decorators = decorators;\n    }\n    return elt;\n  }\n\n  // Used by flow/typescript plugin to add type annotations to binding elements\n  parseAssignableListItemTypes(\n    param: Pattern,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    flags: ParseBindingListFlags,\n  ): Pattern {\n    return param;\n  }\n\n  // Parses assignment pattern around given atom if possible.\n  // https://tc39.es/ecma262/#prod-BindingElement\n  parseMaybeDefault(\n    this: Parser,\n    startLoc?: Position | null,\n    left?: Pattern | null,\n  ): Pattern {\n    startLoc ??= this.state.startLoc;\n    left = left ?? this.parseBindingAtom();\n    if (!this.eat(tt.eq)) return left;\n\n    const node = this.startNodeAt<AssignmentPattern>(startLoc);\n    node.left = left;\n    node.right = this.parseMaybeAssignAllowIn();\n    return this.finishNode(node, \"AssignmentPattern\");\n  }\n  /**\n   * Return information use in determining whether a Node of a given type is an LVal,\n   * possibly given certain additional context information.\n   *\n   * Subclasser notes: This method has kind of a lot of mixed, but related,\n   * responsibilities. If we can definitively determine with the information\n   * provided that this either *is* or *isn't* a valid `LVal`, then the return\n   * value is easy: just return `true` or `false`. However, if it is a valid\n   * LVal *ancestor*, and thus its descendants must be subsequently visited to\n   * continue the \"investigation\", then this method should return the relevant\n   * child key as a `string`. In some special cases, you additionally want to\n   * convey that this node should be treated as if it were parenthesized. In\n   * that case, a tuple of [key: string, parenthesized: boolean] is returned.\n   * The `string`-only return option is actually just a shorthand for:\n   * `[key: string, parenthesized: false]`.\n   *\n   * @param type A Node `type` string\n   * @param isUnparenthesizedInAssign\n   *        Whether the node in question is unparenthesized and its parent\n   *        is either an assignment pattern or an assignment expression.\n   * @param binding\n   *        The binding operation that is being considered for this potential\n   *        LVal.\n   * @returns `true` or `false` if we can immediately determine whether the node\n   *          type in question can be treated as an `LVal`.\n   *          A `string` key to traverse if we must check this child.\n   *          A `[string, boolean]` tuple if we need to check this child and\n   *          treat is as parenthesized.\n   */\n  isValidLVal(\n    type: string,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    isUnparenthesizedInAssign: boolean,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    binding: BindingTypes,\n  ): string | boolean {\n    return getOwn(\n      {\n        AssignmentPattern: \"left\",\n        RestElement: \"argument\",\n        ObjectProperty: \"value\",\n        ParenthesizedExpression: \"expression\",\n        ArrayPattern: \"elements\",\n        ObjectPattern: \"properties\",\n      },\n      // @ts-expect-error refine string to enum\n      type,\n    );\n  }\n\n  /**\n   * Verify that a target expression is an lval (something that can be assigned to).\n   *\n   * @param expression The expression in question to check.\n   * @param options A set of options described below.\n   * @param options.in\n   *        The relevant ancestor to provide context information for the error\n   *        if the check fails.\n   * @param options.binding\n   *        The desired binding type. If the given expression is an identifier\n   *        and `binding` is not `BIND_NONE`, `checkLVal` will register binding\n   *        to the parser scope See also `src/util/scopeflags.js`\n   * @param options.checkClashes\n   *        An optional string set to check if an identifier name is included.\n   *        `checkLVal` will add checked identifier name to `checkClashes` It is\n   *        used in tracking duplicates in function parameter lists. If it is\n   *        false, `checkLVal` will skip duplicate checks\n   * @param options.strictModeChanged\n   *        Whether an identifier has been parsed in a sloppy context but should\n   *        be reinterpreted as strict-mode. e.g. `(arguments) => { \"use strict \"}`\n   * @param options.hasParenthesizedAncestor\n   *        This is only used internally during recursive calls, and you should\n   *        not have to set it yourself.\n   */\n\n  checkLVal(\n    expression: Expression | ObjectMember | RestElement,\n    {\n      in: ancestor,\n      binding = BIND_NONE,\n      checkClashes = false,\n      strictModeChanged = false,\n      hasParenthesizedAncestor = false,\n    }: {\n      in: LValAncestor;\n      binding?: BindingTypes;\n      checkClashes?: Set<string> | false;\n      strictModeChanged?: boolean;\n      hasParenthesizedAncestor?: boolean;\n    },\n  ): void {\n    const type = expression.type;\n\n    // If we find here an ObjectMethod, it's because this was originally\n    // an ObjectExpression which has then been converted.\n    // toAssignable already reported this error with a nicer message.\n    if (this.isObjectMethod(expression)) return;\n\n    if (type === \"MemberExpression\") {\n      if (binding !== BIND_NONE) {\n        this.raise(Errors.InvalidPropertyBindingPattern, { at: expression });\n      }\n      return;\n    }\n\n    if (type === \"Identifier\") {\n      this.checkIdentifier(\n        expression as Identifier,\n        binding,\n        strictModeChanged,\n      );\n\n      const { name } = expression as Identifier;\n\n      if (checkClashes) {\n        if (checkClashes.has(name)) {\n          this.raise(Errors.ParamDupe, { at: expression });\n        } else {\n          checkClashes.add(name);\n        }\n      }\n\n      return;\n    }\n\n    const validity = this.isValidLVal(\n      type,\n      !(hasParenthesizedAncestor || expression.extra?.parenthesized) &&\n        ancestor.type === \"AssignmentExpression\",\n      binding,\n    );\n\n    if (validity === true) return;\n    if (validity === false) {\n      const ParseErrorClass =\n        binding === BIND_NONE ? Errors.InvalidLhs : Errors.InvalidLhsBinding;\n\n      this.raise(ParseErrorClass, { at: expression, ancestor });\n      return;\n    }\n\n    const [key, isParenthesizedExpression] = Array.isArray(validity)\n      ? validity\n      : [validity, type === \"ParenthesizedExpression\"];\n    const nextAncestor =\n      type === \"ArrayPattern\" ||\n      type === \"ObjectPattern\" ||\n      type === \"ParenthesizedExpression\"\n        ? ({ type } as const)\n        : ancestor;\n\n    // @ts-expect-error key may not index expression.\n    for (const child of [].concat(expression[key])) {\n      if (child) {\n        this.checkLVal(child, {\n          in: nextAncestor,\n          binding,\n          checkClashes,\n          strictModeChanged,\n          hasParenthesizedAncestor: isParenthesizedExpression,\n        });\n      }\n    }\n  }\n\n  checkIdentifier(\n    at: Identifier,\n    bindingType: BindingTypes,\n    strictModeChanged: boolean = false,\n  ) {\n    if (\n      this.state.strict &&\n      (strictModeChanged\n        ? isStrictBindReservedWord(at.name, this.inModule)\n        : isStrictBindOnlyReservedWord(at.name))\n    ) {\n      if (bindingType === BIND_NONE) {\n        this.raise(Errors.StrictEvalArguments, { at, referenceName: at.name });\n      } else {\n        this.raise(Errors.StrictEvalArgumentsBinding, {\n          at,\n          bindingName: at.name,\n        });\n      }\n    }\n\n    if (bindingType & BIND_FLAGS_NO_LET_IN_LEXICAL && at.name === \"let\") {\n      this.raise(Errors.LetInLexicalBinding, { at });\n    }\n\n    if (!(bindingType & BIND_NONE)) {\n      this.declareNameFromIdentifier(at, bindingType);\n    }\n  }\n\n  declareNameFromIdentifier(identifier: Identifier, binding: BindingTypes) {\n    this.scope.declareName(identifier.name, binding, identifier.loc.start);\n  }\n\n  checkToRestConversion(node: Node, allowPattern: boolean): void {\n    switch (node.type) {\n      case \"ParenthesizedExpression\":\n        this.checkToRestConversion(node.expression, allowPattern);\n        break;\n      case \"Identifier\":\n      case \"MemberExpression\":\n        break;\n      case \"ArrayExpression\":\n      case \"ObjectExpression\":\n        if (allowPattern) break;\n      /* falls through */\n      default:\n        this.raise(Errors.InvalidRestAssignmentPattern, { at: node });\n    }\n  }\n\n  checkCommaAfterRest(\n    close: (typeof charCodes)[keyof typeof charCodes],\n  ): boolean {\n    if (!this.match(tt.comma)) {\n      return false;\n    }\n\n    this.raise(\n      this.lookaheadCharCode() === close\n        ? Errors.RestTrailingComma\n        : Errors.ElementAfterRest,\n      { at: this.state.startLoc },\n    );\n\n    return true;\n  }\n}\n"],"mappings":"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"}������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������lib/parser/node.js����������������������������������������������������������������������������������0000644�����������������00000006475�15120211212�0010070 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.NodeUtils = void 0;
exports.cloneIdentifier = cloneIdentifier;
exports.cloneStringLiteral = cloneStringLiteral;
var _util = require("./util");
var _location = require("../util/location");
class Node {
  constructor(parser, pos, loc) {
    this.type = "";
    this.start = pos;
    this.end = 0;
    this.loc = new _location.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(undefined, this.start, this.loc.start);
    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 _util.default {
  startNode() {
    return new Node(this, this.state.start, this.state.startLoc);
  }
  startNodeAt(loc) {
    return new Node(this, loc.index, loc);
  }
  startNodeAtNode(type) {
    return this.startNodeAt(type.loc.start);
  }
  finishNode(node, type) {
    return this.finishNodeAt(node, type, this.state.lastTokEndLoc);
  }
  finishNodeAt(node, type, endLoc) {
    if (process.env.NODE_ENV !== "production" && node.end > 0) {
      throw new Error("Do not call finishNode*() twice on the same node." + " Instead use resetEndLocation() or change type directly.");
    }
    node.type = type;
    node.end = 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, startLoc) {
    node.start = startLoc.index;
    node.loc.start = startLoc;
    if (this.options.ranges) node.range[0] = startLoc.index;
  }
  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.loc.start);
  }
}
exports.NodeUtils = NodeUtils;

//# sourceMappingURL=node.js.map
���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������lib/parser/node.js.map������������������������������������������������������������������������������0000644�����������������00000023554�15120211212�0010641 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������{"version":3,"names":["_util","require","_location","Node","constructor","parser","pos","loc","type","start","end","SourceLocation","options","ranges","range","filename","NodePrototype","prototype","__clone","newNode","undefined","keys","Object","i","length","key","clonePlaceholder","node","cloneIdentifier","extra","name","cloned","create","expectedNode","cloneStringLiteral","raw","value","NodeUtils","UtilParser","startNode","state","startLoc","startNodeAt","index","startNodeAtNode","finishNode","finishNodeAt","lastTokEndLoc","endLoc","process","env","NODE_ENV","Error","attachComment","processComment","resetStartLocation","resetEndLocation","resetStartLocationFromNode","locationNode","exports"],"sources":["../../src/parser/node.ts"],"sourcesContent":["import type Parser from \"./index\";\nimport UtilParser from \"./util\";\nimport { SourceLocation, type Position } from \"../util/location\";\nimport type { Comment, Node as NodeType, NodeBase } from \"../types\";\n\n// Start an AST node, attaching a start offset.\n\nclass Node implements NodeBase {\n  constructor(parser: Parser, pos: number, loc: Position) {\n    this.start = pos;\n    this.end = 0;\n    this.loc = new SourceLocation(loc);\n    if (parser?.options.ranges) this.range = [pos, 0];\n    if (parser?.filename) this.loc.filename = parser.filename;\n  }\n\n  type: string = \"\";\n  declare start: number;\n  declare end: number;\n  declare loc: SourceLocation;\n  declare range: [number, number];\n  declare leadingComments: Array<Comment>;\n  declare trailingComments: Array<Comment>;\n  declare innerComments: Array<Comment>;\n  declare extra: {\n    [key: string]: any;\n  };\n}\nconst NodePrototype = Node.prototype;\n\nif (!process.env.BABEL_8_BREAKING) {\n  // @ts-expect-error __clone is not defined in Node prototype\n  NodePrototype.__clone = function (): Node {\n    const newNode = new Node(undefined, this.start, this.loc.start);\n    const keys = Object.keys(this) as (keyof Node)[];\n    for (let i = 0, length = keys.length; i < length; i++) {\n      const key = keys[i];\n      // Do not clone comments that are already attached to the node\n      if (\n        key !== \"leadingComments\" &&\n        key !== \"trailingComments\" &&\n        key !== \"innerComments\"\n      ) {\n        // @ts-expect-error cloning this to newNode\n        newNode[key] = this[key];\n      }\n    }\n\n    return newNode;\n  };\n}\n\nfunction clonePlaceholder(node: any): any {\n  return cloneIdentifier(node);\n}\n\nexport function cloneIdentifier(node: any): any {\n  // We don't need to clone `typeAnnotations` and `optional`: because\n  // cloneIdentifier is only used in object shorthand and named import/export.\n  // Neither of them allow type annotations after the identifier or optional identifier\n  const { type, start, end, loc, range, extra, name } = node;\n  const cloned = Object.create(NodePrototype);\n  cloned.type = type;\n  cloned.start = start;\n  cloned.end = end;\n  cloned.loc = loc;\n  cloned.range = range;\n  cloned.extra = extra;\n  cloned.name = name;\n  if (type === \"Placeholder\") {\n    cloned.expectedNode = node.expectedNode;\n  }\n  return cloned;\n}\n\nexport function cloneStringLiteral(node: any): any {\n  const { type, start, end, loc, range, extra } = node;\n  if (type === \"Placeholder\") {\n    return clonePlaceholder(node);\n  }\n  const cloned = Object.create(NodePrototype);\n  cloned.type = type;\n  cloned.start = start;\n  cloned.end = end;\n  cloned.loc = loc;\n  cloned.range = range;\n  if (node.raw !== undefined) {\n    // estree set node.raw instead of node.extra\n    cloned.raw = node.raw;\n  } else {\n    cloned.extra = extra;\n  }\n  cloned.value = node.value;\n  return cloned;\n}\n\nexport type Undone<T extends NodeType> = Omit<T, \"type\">;\n\nexport abstract class NodeUtils extends UtilParser {\n  startNode<T extends NodeType>(): Undone<T> {\n    // @ts-expect-error cast Node as Undone<T>\n    return new Node(this, this.state.start, this.state.startLoc);\n  }\n\n  startNodeAt<T extends NodeType>(loc: Position): Undone<T> {\n    // @ts-expect-error cast Node as Undone<T>\n    return new Node(this, loc.index, loc);\n  }\n\n  /** Start a new node with a previous node's location. */\n  startNodeAtNode<T extends NodeType>(type: Undone<NodeType>): Undone<T> {\n    return this.startNodeAt(type.loc.start);\n  }\n\n  // Finish an AST node, adding `type` and `end` properties.\n\n  finishNode<T extends NodeType>(node: Undone<T>, type: T[\"type\"]): T {\n    return this.finishNodeAt(node, type, this.state.lastTokEndLoc);\n  }\n\n  // Finish node at given position\n\n  finishNodeAt<T extends NodeType>(\n    node: Omit<T, \"type\">,\n    type: T[\"type\"],\n    endLoc: Position,\n  ): T {\n    if (process.env.NODE_ENV !== \"production\" && node.end > 0) {\n      throw new Error(\n        \"Do not call finishNode*() twice on the same node.\" +\n          \" Instead use resetEndLocation() or change type directly.\",\n      );\n    }\n    // @ts-expect-error migrate to Babel types AST typings\n    node.type = type;\n    // @ts-expect-error migrate to Babel types AST typings\n    node.end = endLoc.index;\n    node.loc.end = endLoc;\n    if (this.options.ranges) node.range[1] = endLoc.index;\n    if (this.options.attachComment) this.processComment(node as T);\n    return node as T;\n  }\n\n  resetStartLocation(node: NodeBase, startLoc: Position): void {\n    node.start = startLoc.index;\n    node.loc.start = startLoc;\n    if (this.options.ranges) node.range[0] = startLoc.index;\n  }\n\n  resetEndLocation(\n    node: NodeBase,\n    endLoc: Position = this.state.lastTokEndLoc,\n  ): void {\n    node.end = endLoc.index;\n    node.loc.end = endLoc;\n    if (this.options.ranges) node.range[1] = endLoc.index;\n  }\n\n  /**\n   * Reset the start location of node to the start location of locationNode\n   */\n  resetStartLocationFromNode(node: NodeBase, locationNode: NodeBase): void {\n    this.resetStartLocation(node, locationNode.loc.start);\n  }\n}\n"],"mappings":"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"}����������������������������������������������������������������������������������������������������������������������������������������������������lib/parser/statement.js�����������������������������������������������������������������������������0000644�����������������00000215056�15120211212�0011144 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = exports.ParseStatementFlag = exports.ParseFunctionFlag = void 0;
var _types = require("../tokenizer/types");
var _expression = require("./expression");
var _parseError = require("../parse-error");
var _identifier = require("../util/identifier");
var _scopeflags = require("../util/scopeflags");
var _util = require("./util");
var _productionParameter = require("../util/production-parameter");
var _expressionScope = require("../util/expression-scope");
var _tokenizer = require("../tokenizer");
var _location = require("../util/location");
var _node = require("./node");
var _lval = require("./lval");
const loopLabel = {
    kind: "loop"
  },
  switchLabel = {
    kind: "switch"
  };
var ParseFunctionFlag = {
  Expression: 0,
  Declaration: 1,
  HangingDeclaration: 2,
  NullableId: 4,
  Async: 8
};
exports.ParseFunctionFlag = ParseFunctionFlag;
var ParseStatementFlag = {
  StatementOnly: 0,
  AllowImportExport: 1,
  AllowDeclaration: 2,
  AllowFunctionDeclaration: 4,
  AllowLabeledFunction: 8
};
exports.ParseStatementFlag = ParseStatementFlag;
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 === 136) {
          const {
            loc,
            start,
            value,
            end
          } = token;
          const hashEndPos = start + 1;
          const hashEndLoc = (0, _location.createPositionWithColumnOffset)(loc.start, 1);
          tokens.splice(i, 1, new _tokenizer.Token({
            type: (0, _types.getExportedToken)(27),
            value: "#",
            start: start,
            end: hashEndPos,
            startLoc: loc.start,
            endLoc: hashEndLoc
          }), new _tokenizer.Token({
            type: (0, _types.getExportedToken)(130),
            value: value,
            start: hashEndPos,
            end: end,
            startLoc: hashEndLoc,
            endLoc: loc.end
          }));
          i++;
          continue;
        }
        if ((0, _types.tokenIsTemplate)(type)) {
          const {
            loc,
            start,
            value,
            end
          } = token;
          const backquoteEnd = start + 1;
          const backquoteEndLoc = (0, _location.createPositionWithColumnOffset)(loc.start, 1);
          let startToken;
          if (input.charCodeAt(start) === 96) {
            startToken = new _tokenizer.Token({
              type: (0, _types.getExportedToken)(22),
              value: "`",
              start: start,
              end: backquoteEnd,
              startLoc: loc.start,
              endLoc: backquoteEndLoc
            });
          } else {
            startToken = new _tokenizer.Token({
              type: (0, _types.getExportedToken)(8),
              value: "}",
              start: start,
              end: backquoteEnd,
              startLoc: loc.start,
              endLoc: backquoteEndLoc
            });
          }
          let templateValue, templateElementEnd, templateElementEndLoc, endToken;
          if (type === 24) {
            templateElementEnd = end - 1;
            templateElementEndLoc = (0, _location.createPositionWithColumnOffset)(loc.end, -1);
            templateValue = value === null ? null : value.slice(1, -1);
            endToken = new _tokenizer.Token({
              type: (0, _types.getExportedToken)(22),
              value: "`",
              start: templateElementEnd,
              end: end,
              startLoc: templateElementEndLoc,
              endLoc: loc.end
            });
          } else {
            templateElementEnd = end - 2;
            templateElementEndLoc = (0, _location.createPositionWithColumnOffset)(loc.end, -2);
            templateValue = value === null ? null : value.slice(1, -2);
            endToken = new _tokenizer.Token({
              type: (0, _types.getExportedToken)(23),
              value: "${",
              start: templateElementEnd,
              end: end,
              startLoc: templateElementEndLoc,
              endLoc: loc.end
            });
          }
          tokens.splice(i, 1, startToken, new _tokenizer.Token({
            type: (0, _types.getExportedToken)(20),
            value: templateValue,
            start: backquoteEnd,
            end: templateElementEnd,
            startLoc: backquoteEndLoc,
            endLoc: templateElementEndLoc
          }), endToken);
          i += 2;
          continue;
        }
      }
      token.type = (0, _types.getExportedToken)(type);
    }
  }
  return tokens;
}
class StatementParser extends _expression.default {
  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 = 137, 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 [localName, at] of Array.from(this.scope.undefinedExports)) {
        this.raise(_parseError.Errors.ModuleExportUndefined, {
          at,
          localName
        });
      }
    }
    let finishedProgram;
    if (end === 137) {
      finishedProgram = this.finishNode(program, "Program");
    } else {
      finishedProgram = this.finishNodeAt(program, "Program", (0, _location.createPositionWithColumnOffset)(this.state.startLoc, -1));
    }
    return finishedProgram;
  }
  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() {
    if (!this.isContextual(99)) {
      return false;
    }
    return this.hasFollowingBindingAtom();
  }
  chStartsBindingIdentifier(ch, pos) {
    if ((0, _identifier.isIdentifierStart)(ch)) {
      keywordRelationalOperator.lastIndex = pos;
      if (keywordRelationalOperator.test(this.input)) {
        const endCh = this.codePointAtPos(keywordRelationalOperator.lastIndex);
        if (!(0, _identifier.isIdentifierChar)(endCh) && endCh !== 92) {
          return false;
        }
      }
      return true;
    } else if (ch === 92) {
      return true;
    } else {
      return false;
    }
  }
  chStartsBindingPattern(ch) {
    return ch === 91 || ch === 123;
  }
  hasFollowingBindingAtom() {
    const next = this.nextTokenStart();
    const nextCh = this.codePointAtPos(next);
    return this.chStartsBindingPattern(nextCh) || this.chStartsBindingIdentifier(nextCh, next);
  }
  hasInLineFollowingBindingIdentifier() {
    const next = this.nextTokenInLineStart();
    const nextCh = this.codePointAtPos(next);
    return this.chStartsBindingIdentifier(nextCh, next);
  }
  startsUsingForOf() {
    const {
      type,
      containsEsc
    } = this.lookahead();
    if (type === 101 && !containsEsc) {
      return false;
    } else if ((0, _types.tokenIsIdentifier)(type) && !this.hasFollowingLineBreak()) {
      this.expectPlugin("explicitResourceManagement");
      return true;
    }
  }
  startsAwaitUsing() {
    let next = this.nextTokenInLineStart();
    if (this.isUnparsedContextual(next, "using")) {
      next = this.nextTokenInLineStartSince(next + 5);
      const nextCh = this.codePointAtPos(next);
      if (this.chStartsBindingIdentifier(nextCh, next)) {
        this.expectPlugin("explicitResourceManagement");
        return true;
      }
    }
    return false;
  }
  parseModuleItem() {
    return this.parseStatementLike(ParseStatementFlag.AllowImportExport | ParseStatementFlag.AllowDeclaration | ParseStatementFlag.AllowFunctionDeclaration | ParseStatementFlag.AllowLabeledFunction);
  }
  parseStatementListItem() {
    return this.parseStatementLike(ParseStatementFlag.AllowDeclaration | ParseStatementFlag.AllowFunctionDeclaration | (!this.options.annexB || this.state.strict ? 0 : ParseStatementFlag.AllowLabeledFunction));
  }
  parseStatementOrSloppyAnnexBFunctionDeclaration(allowLabeledFunction = false) {
    let flags = ParseStatementFlag.StatementOnly;
    if (this.options.annexB && !this.state.strict) {
      flags |= ParseStatementFlag.AllowFunctionDeclaration;
      if (allowLabeledFunction) {
        flags |= ParseStatementFlag.AllowLabeledFunction;
      }
    }
    return this.parseStatementLike(flags);
  }
  parseStatement() {
    return this.parseStatementLike(ParseStatementFlag.StatementOnly);
  }
  parseStatementLike(flags) {
    let decorators = null;
    if (this.match(26)) {
      decorators = this.parseDecorators(true);
    }
    return this.parseStatementContent(flags, decorators);
  }
  parseStatementContent(flags, decorators) {
    const starttype = this.state.type;
    const node = this.startNode();
    const allowDeclaration = !!(flags & ParseStatementFlag.AllowDeclaration);
    const allowFunctionDeclaration = !!(flags & ParseStatementFlag.AllowFunctionDeclaration);
    const topLevel = flags & ParseStatementFlag.AllowImportExport;
    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.parseDoWhileStatement(node);
      case 91:
        return this.parseForStatement(node);
      case 68:
        if (this.lookaheadCharCode() === 46) break;
        if (!allowFunctionDeclaration) {
          this.raise(this.state.strict ? _parseError.Errors.StrictFunction : this.options.annexB ? _parseError.Errors.SloppyFunctionAnnexB : _parseError.Errors.SloppyFunction, {
            at: this.state.startLoc
          });
        }
        return this.parseFunctionStatement(node, false, !allowDeclaration && allowFunctionDeclaration);
      case 80:
        if (!allowDeclaration) this.unexpected();
        return this.parseClass(this.maybeTakeDecorators(decorators, 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 96:
        if (!this.state.containsEsc && this.startsAwaitUsing()) {
          if (!this.isAwaitAllowed()) {
            this.raise(_parseError.Errors.AwaitUsingNotInAsyncContext, {
              at: node
            });
          } else if (!allowDeclaration) {
            this.raise(_parseError.Errors.UnexpectedLexicalDeclaration, {
              at: node
            });
          }
          this.next();
          return this.parseVarStatement(node, "await using");
        }
        break;
      case 105:
        if (this.state.containsEsc || !this.hasInLineFollowingBindingIdentifier()) {
          break;
        }
        this.expectPlugin("explicitResourceManagement");
        if (!this.scope.inModule && this.scope.inTopLevel) {
          this.raise(_parseError.Errors.UnexpectedUsingDeclaration, {
            at: this.state.startLoc
          });
        } else if (!allowDeclaration) {
          this.raise(_parseError.Errors.UnexpectedLexicalDeclaration, {
            at: this.state.startLoc
          });
        }
        return this.parseVarStatement(node, "using");
      case 99:
        {
          if (this.state.containsEsc) {
            break;
          }
          const next = this.nextTokenStart();
          const nextCh = this.codePointAtPos(next);
          if (nextCh !== 91) {
            if (!allowDeclaration && this.hasFollowingLineBreak()) break;
            if (!this.chStartsBindingIdentifier(nextCh, next) && nextCh !== 123) {
              break;
            }
          }
        }
      case 75:
        {
          if (!allowDeclaration) {
            this.raise(_parseError.Errors.UnexpectedLexicalDeclaration, {
              at: this.state.startLoc
            });
          }
        }
      case 74:
        {
          const kind = this.state.value;
          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(_parseError.Errors.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, decorators);
            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(result);
          return result;
        }
      default:
        {
          if (this.isAsyncFunction()) {
            if (!allowDeclaration) {
              this.raise(_parseError.Errors.AsyncFunctionInSingleStatementContext, {
                at: this.state.startLoc
              });
            }
            this.next();
            return this.parseFunctionStatement(node, true, !allowDeclaration && allowFunctionDeclaration);
          }
        }
    }
    const maybeName = this.state.value;
    const expr = this.parseExpression();
    if ((0, _types.tokenIsIdentifier)(starttype) && expr.type === "Identifier" && this.eat(14)) {
      return this.parseLabeledStatement(node, maybeName, expr, flags);
    } else {
      return this.parseExpressionStatement(node, expr, decorators);
    }
  }
  assertModuleNodeAllowed(node) {
    if (!this.options.allowImportExportEverywhere && !this.inModule) {
      this.raise(_parseError.Errors.ImportOutsideModule, {
        at: node
      });
    }
  }
  decoratorsEnabledBeforeExport() {
    if (this.hasPlugin("decorators-legacy")) return true;
    return this.hasPlugin("decorators") && this.getPluginOption("decorators", "decoratorsBeforeExport") !== false;
  }
  maybeTakeDecorators(maybeDecorators, classNode, exportNode) {
    if (maybeDecorators) {
      if (classNode.decorators && classNode.decorators.length > 0) {
        if (typeof this.getPluginOption("decorators", "decoratorsBeforeExport") !== "boolean") {
          this.raise(_parseError.Errors.DecoratorsBeforeAfterExport, {
            at: classNode.decorators[0]
          });
        }
        classNode.decorators.unshift(...maybeDecorators);
      } else {
        classNode.decorators = maybeDecorators;
      }
      this.resetStartLocationFromNode(classNode, maybeDecorators[0]);
      if (exportNode) this.resetStartLocationFromNode(exportNode, classNode);
    }
    return classNode;
  }
  canHaveLeadingDecorator() {
    return this.match(80);
  }
  parseDecorators(allowExport) {
    const decorators = [];
    do {
      decorators.push(this.parseDecorator());
    } while (this.match(26));
    if (this.match(82)) {
      if (!allowExport) {
        this.unexpected();
      }
      if (!this.decoratorsEnabledBeforeExport()) {
        this.raise(_parseError.Errors.DecoratorExportClass, {
          at: this.state.startLoc
        });
      }
    } else if (!this.canHaveLeadingDecorator()) {
      throw this.raise(_parseError.Errors.UnexpectedLeadingDecorator, {
        at: this.state.startLoc
      });
    }
    return decorators;
  }
  parseDecorator() {
    this.expectOnePlugin(["decorators", "decorators-legacy"]);
    const node = this.startNode();
    this.next();
    if (this.hasPlugin("decorators")) {
      const startLoc = this.state.startLoc;
      let expr;
      if (this.match(10)) {
        const startLoc = this.state.startLoc;
        this.next();
        expr = this.parseExpression();
        this.expect(11);
        expr = this.wrapParenthesis(startLoc, expr);
        const paramsStartLoc = this.state.startLoc;
        node.expression = this.parseMaybeDecoratorArguments(expr);
        if (this.getPluginOption("decorators", "allowCallParenthesized") === false && node.expression !== expr) {
          this.raise(_parseError.Errors.DecoratorArgumentsOutsideParentheses, {
            at: paramsStartLoc
          });
        }
      } else {
        expr = this.parseIdentifier(false);
        while (this.eat(16)) {
          const node = this.startNodeAt(startLoc);
          node.object = expr;
          if (this.match(136)) {
            this.classScope.usePrivateName(this.state.value, this.state.startLoc);
            node.property = this.parsePrivateName();
          } else {
            node.property = this.parseIdentifier(true);
          }
          node.computed = false;
          expr = this.finishNode(node, "MemberExpression");
        }
        node.expression = this.parseMaybeDecoratorArguments(expr);
      }
    } 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) {
      const type = isBreak ? "BreakStatement" : "ContinueStatement";
      this.raise(_parseError.Errors.IllegalBreakContinue, {
        at: node,
        type
      });
    }
  }
  parseDebuggerStatement(node) {
    this.next();
    this.semicolon();
    return this.finishNode(node, "DebuggerStatement");
  }
  parseHeaderExpression() {
    this.expect(10);
    const val = this.parseExpression();
    this.expect(11);
    return val;
  }
  parseDoWhileStatement(node) {
    this.next();
    this.state.labels.push(loopLabel);
    node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement());
    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(_scopeflags.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 startsWithAwaitUsing = this.isContextual(96) && this.startsAwaitUsing();
      const starsWithUsingDeclaration = startsWithAwaitUsing || this.isContextual(105) && this.startsUsingForOf();
      const isLetOrUsing = startsWithLet && this.hasFollowingBindingAtom() || starsWithUsingDeclaration;
      if (this.match(74) || this.match(75) || isLetOrUsing) {
        const initNode = this.startNode();
        let kind;
        if (startsWithAwaitUsing) {
          kind = "await using";
          if (!this.isAwaitAllowed()) {
            this.raise(_parseError.Errors.AwaitUsingNotInAsyncContext, {
              at: this.state.startLoc
            });
          }
          this.next();
        } else {
          kind = this.state.value;
        }
        this.next();
        this.parseVar(initNode, true, kind);
        const init = this.finishNode(initNode, "VariableDeclaration");
        const isForIn = this.match(58);
        if (isForIn && starsWithUsingDeclaration) {
          this.raise(_parseError.Errors.ForInUsing, {
            at: init
          });
        }
        if ((isForIn || 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 _util.ExpressionErrors();
    const init = this.parseExpression(true, refExpressionErrors);
    const isForOf = this.isContextual(101);
    if (isForOf) {
      if (startsWithLet) {
        this.raise(_parseError.Errors.ForOfLet, {
          at: init
        });
      }
      if (awaitAt === null && startsWithAsync && init.type === "Identifier") {
        this.raise(_parseError.Errors.ForOfAsync, {
          at: init
        });
      }
    }
    if (isForOf || this.match(58)) {
      this.checkDestructuringPrivate(refExpressionErrors);
      this.toAssignable(init, true);
      const type = isForOf ? "ForOfStatement" : "ForInStatement";
      this.checkLVal(init, {
        in: {
          type
        }
      });
      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, isHangingDeclaration) {
    this.next();
    return this.parseFunction(node, ParseFunctionFlag.Declaration | (isHangingDeclaration ? ParseFunctionFlag.HangingDeclaration : 0) | (isAsync ? ParseFunctionFlag.Async : 0));
  }
  parseIfStatement(node) {
    this.next();
    node.test = this.parseHeaderExpression();
    node.consequent = this.parseStatementOrSloppyAnnexBFunctionDeclaration();
    node.alternate = this.eat(66) ? this.parseStatementOrSloppyAnnexBFunctionDeclaration() : null;
    return this.finishNode(node, "IfStatement");
  }
  parseReturnStatement(node) {
    if (!this.prodParam.hasReturn && !this.options.allowReturnOutsideFunction) {
      this.raise(_parseError.Errors.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(_scopeflags.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(_parseError.Errors.MultipleDefaultsInSwitch, {
              at: this.state.lastTokStartLoc
            });
          }
          sawDefault = true;
          cur.test = null;
        }
        this.expect(14);
      } else {
        if (cur) {
          cur.consequent.push(this.parseStatementListItem());
        } 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(_parseError.Errors.NewlineAfterThrow, {
        at: this.state.lastTokEndLoc
      });
    }
    node.argument = this.parseExpression();
    this.semicolon();
    return this.finishNode(node, "ThrowStatement");
  }
  parseCatchClauseParam() {
    const param = this.parseBindingAtom();
    this.scope.enter(this.options.annexB && param.type === "Identifier" ? _scopeflags.SCOPE_SIMPLE_CATCH : 0);
    this.checkLVal(param, {
      in: {
        type: "CatchClause"
      },
      binding: _scopeflags.BIND_CATCH_PARAM
    });
    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(_scopeflags.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(_parseError.Errors.NoCatchOrFinally, {
        at: node
      });
    }
    return this.finishNode(node, "TryStatement");
  }
  parseVarStatement(node, kind, allowMissingInitializer = false) {
    this.next();
    this.parseVar(node, false, kind, allowMissingInitializer);
    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());
    this.state.labels.pop();
    return this.finishNode(node, "WhileStatement");
  }
  parseWithStatement(node) {
    if (this.state.strict) {
      this.raise(_parseError.Errors.StrictWith, {
        at: this.state.startLoc
      });
    }
    this.next();
    node.object = this.parseHeaderExpression();
    node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement());
    return this.finishNode(node, "WithStatement");
  }
  parseEmptyStatement(node) {
    this.next();
    return this.finishNode(node, "EmptyStatement");
  }
  parseLabeledStatement(node, maybeName, expr, flags) {
    for (const label of this.state.labels) {
      if (label.name === maybeName) {
        this.raise(_parseError.Errors.LabelRedeclaration, {
          at: expr,
          labelName: maybeName
        });
      }
    }
    const kind = (0, _types.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 = flags & ParseStatementFlag.AllowLabeledFunction ? this.parseStatementOrSloppyAnnexBFunctionDeclaration(true) : this.parseStatement();
    this.state.labels.pop();
    node.label = expr;
    return this.finishNode(node, "LabeledStatement");
  }
  parseExpressionStatement(node, expr, decorators) {
    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(_scopeflags.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 = topLevel ? this.parseModuleItem() : this.parseStatementListItem();
      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());
    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.options.annexB || this.state.strict || init.kind !== "var" || init.declarations[0].id.type !== "Identifier")) {
      this.raise(_parseError.Errors.ForInOfLoopInitializer, {
        at: init,
        type: isForIn ? "ForInStatement" : "ForOfStatement"
      });
    }
    if (init.type === "AssignmentPattern") {
      this.raise(_parseError.Errors.InvalidLhs, {
        at: init,
        ancestor: {
          type: "ForStatement"
        }
      });
    }
    node.left = init;
    node.right = isForIn ? this.parseExpression() : this.parseMaybeAssignAllowIn();
    this.expect(11);
    node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement());
    this.scope.exit();
    this.state.labels.pop();
    return this.finishNode(node, isForIn ? "ForInStatement" : "ForOfStatement");
  }
  parseVar(node, isFor, kind, allowMissingInitializer = false) {
    const declarations = node.declarations = [];
    node.kind = kind;
    for (;;) {
      const decl = this.startNode();
      this.parseVarId(decl, kind);
      decl.init = !this.eat(29) ? null : isFor ? this.parseMaybeAssignDisallowIn() : this.parseMaybeAssignAllowIn();
      if (decl.init === null && !allowMissingInitializer) {
        if (decl.id.type !== "Identifier" && !(isFor && (this.match(58) || this.isContextual(101)))) {
          this.raise(_parseError.Errors.DeclarationMissingInitializer, {
            at: this.state.lastTokEndLoc,
            kind: "destructuring"
          });
        } else if (kind === "const" && !(this.match(58) || this.isContextual(101))) {
          this.raise(_parseError.Errors.DeclarationMissingInitializer, {
            at: this.state.lastTokEndLoc,
            kind: "const"
          });
        }
      }
      declarations.push(this.finishNode(decl, "VariableDeclarator"));
      if (!this.eat(12)) break;
    }
    return node;
  }
  parseVarId(decl, kind) {
    const id = this.parseBindingAtom();
    this.checkLVal(id, {
      in: {
        type: "VariableDeclarator"
      },
      binding: kind === "var" ? _scopeflags.BIND_VAR : _scopeflags.BIND_LEXICAL
    });
    decl.id = id;
  }
  parseAsyncFunctionExpression(node) {
    return this.parseFunction(node, ParseFunctionFlag.Async);
  }
  parseFunction(node, flags = ParseFunctionFlag.Expression) {
    const hangingDeclaration = flags & ParseFunctionFlag.HangingDeclaration;
    const isDeclaration = !!(flags & ParseFunctionFlag.Declaration);
    const requireId = isDeclaration && !(flags & ParseFunctionFlag.NullableId);
    const isAsync = !!(flags & ParseFunctionFlag.Async);
    this.initFunction(node, isAsync);
    if (this.match(55)) {
      if (hangingDeclaration) {
        this.raise(_parseError.Errors.GeneratorInSingleStatementContext, {
          at: this.state.startLoc
        });
      }
      this.next();
      node.generator = true;
    }
    if (isDeclaration) {
      node.id = this.parseFunctionId(requireId);
    }
    const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;
    this.state.maybeInArrowParameters = false;
    this.scope.enter(_scopeflags.SCOPE_FUNCTION);
    this.prodParam.enter((0, _productionParameter.functionFlags)(isAsync, node.generator));
    if (!isDeclaration) {
      node.id = this.parseFunctionId();
    }
    this.parseFunctionParams(node, false);
    this.withSmartMixTopicForbiddingContext(() => {
      this.parseFunctionBodyAndFinish(node, isDeclaration ? "FunctionDeclaration" : "FunctionExpression");
    });
    this.prodParam.exit();
    this.scope.exit();
    if (isDeclaration && !hangingDeclaration) {
      this.registerFunctionStatementId(node);
    }
    this.state.maybeInArrowParameters = oldMaybeInArrowParameters;
    return node;
  }
  parseFunctionId(requireId) {
    return requireId || (0, _types.tokenIsIdentifier)(this.state.type) ? this.parseIdentifier() : null;
  }
  parseFunctionParams(node, isConstructor) {
    this.expect(10);
    this.expressionScope.enter((0, _expressionScope.newParameterDeclarationScope)());
    node.params = this.parseBindingList(11, 41, _lval.ParseBindingListFlags.IS_FUNCTION_PARAMS | (isConstructor ? _lval.ParseBindingListFlags.IS_CONSTRUCTOR_PARAMS : 0));
    this.expressionScope.exit();
  }
  registerFunctionStatementId(node) {
    if (!node.id) return;
    this.scope.declareName(node.id.name, !this.options.annexB || this.state.strict || node.generator || node.async ? this.scope.treatFunctionsAsVar ? _scopeflags.BIND_VAR : _scopeflags.BIND_LEXICAL : _scopeflags.BIND_FUNCTION, node.id.loc.start);
  }
  parseClass(node, isStatement, optionalId) {
    this.next();
    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(_parseError.Errors.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(_parseError.Errors.DecoratorConstructor, {
            at: member
          });
        }
      }
    });
    this.state.strict = oldStrict;
    this.next();
    if (decorators.length) {
      throw this.raise(_parseError.Errors.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(136);
      this.parseClassElementName(method);
      if (isPrivateName) {
        this.pushClassPrivateMethod(classBody, privateMethod, true, false);
        return;
      }
      if (this.isNonstaticConstructor(publicMethod)) {
        this.raise(_parseError.Errors.ConstructorIsGenerator, {
          at: publicMethod.key
        });
      }
      this.pushClassMethod(classBody, publicMethod, true, false, false, false);
      return;
    }
    const isContextual = (0, _types.tokenIsIdentifier)(this.state.type) && !this.state.containsEsc;
    const isPrivate = this.match(136);
    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(_parseError.Errors.DuplicateConstructor, {
            at: key
          });
        }
        if (isConstructor && this.hasPlugin("typescript") && member.override) {
          this.raise(_parseError.Errors.OverrideOnConstructor, {
            at: 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(136);
      this.parseClassElementName(method);
      this.parsePostMemberNameModifiers(publicMember);
      if (isPrivate) {
        this.pushClassPrivateMethod(classBody, privateMethod, isGenerator, true);
      } else {
        if (this.isNonstaticConstructor(publicMethod)) {
          this.raise(_parseError.Errors.ConstructorIsAsync, {
            at: 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(136);
      this.parseClassElementName(publicMethod);
      if (isPrivate) {
        this.pushClassPrivateMethod(classBody, privateMethod, false, false);
      } else {
        if (this.isNonstaticConstructor(publicMethod)) {
          this.raise(_parseError.Errors.ConstructorIsAccessor, {
            at: 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(136);
      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 === 130 || type === 131) && member.static && value === "prototype") {
      this.raise(_parseError.Errors.StaticPrototype, {
        at: this.state.startLoc
      });
    }
    if (type === 136) {
      if (value === "constructor") {
        this.raise(_parseError.Errors.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(_scopeflags.SCOPE_CLASS | _scopeflags.SCOPE_STATIC_BLOCK | _scopeflags.SCOPE_SUPER);
    const oldLabels = this.state.labels;
    this.state.labels = [];
    this.prodParam.enter(_productionParameter.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(_parseError.Errors.DecoratorStaticBlock, {
        at: member
      });
    }
  }
  pushClassProperty(classBody, prop) {
    if (!prop.computed && (prop.key.name === "constructor" || prop.key.value === "constructor")) {
      this.raise(_parseError.Errors.ConstructorClassField, {
        at: 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), _scopeflags.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(_parseError.Errors.ConstructorClassField, {
          at: key
        });
      }
    }
    const node = this.parseClassAccessorProperty(prop);
    classBody.body.push(node);
    if (isPrivate) {
      this.classScope.declarePrivateName(this.getPrivateNameSV(node.key), _scopeflags.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 ? _scopeflags.CLASS_ELEMENT_STATIC_GETTER : _scopeflags.CLASS_ELEMENT_INSTANCE_GETTER : node.kind === "set" ? node.static ? _scopeflags.CLASS_ELEMENT_STATIC_SETTER : _scopeflags.CLASS_ELEMENT_INSTANCE_SETTER : _scopeflags.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(_scopeflags.SCOPE_CLASS | _scopeflags.SCOPE_SUPER);
    this.expressionScope.enter((0, _expressionScope.newExpressionScope)());
    this.prodParam.enter(_productionParameter.PARAM);
    node.value = this.eat(29) ? this.parseMaybeAssignAllowIn() : null;
    this.expressionScope.exit();
    this.prodParam.exit();
    this.scope.exit();
  }
  parseClassId(node, isStatement, optionalId, bindingType = _scopeflags.BIND_CLASS) {
    if ((0, _types.tokenIsIdentifier)(this.state.type)) {
      node.id = this.parseIdentifier();
      if (isStatement) {
        this.declareNameFromIdentifier(node.id, bindingType);
      }
    } else {
      if (optionalId || !isStatement) {
        node.id = null;
      } else {
        throw this.raise(_parseError.Errors.MissingClassName, {
          at: this.state.startLoc
        });
      }
    }
  }
  parseClassSuper(node) {
    node.superClass = this.eat(81) ? this.parseExprSubscripts() : null;
  }
  parseExport(node, decorators) {
    const maybeDefaultIdentifier = this.parseMaybeImportPhase(node, true);
    const hasDefault = this.maybeParseExportDefaultSpecifier(node, maybeDefaultIdentifier);
    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();
      if (decorators) {
        throw this.raise(_parseError.Errors.UnsupportedDecoratorExport, {
          at: node
        });
      }
      this.parseExportFrom(node, true);
      return this.finishNode(node, "ExportAllDeclaration");
    }
    const hasSpecifiers = this.maybeParseExportNamedSpecifiers(node);
    if (hasDefault && parseAfterDefault && !hasStar && !hasSpecifiers) {
      this.unexpected(null, 5);
    }
    if (hasNamespace && parseAfterNamespace) {
      this.unexpected(null, 97);
    }
    let hasDeclaration;
    if (isFromRequired || hasSpecifiers) {
      hasDeclaration = false;
      if (decorators) {
        throw this.raise(_parseError.Errors.UnsupportedDecoratorExport, {
          at: node
        });
      }
      this.parseExportFrom(node, isFromRequired);
    } else {
      hasDeclaration = this.maybeParseExportDeclaration(node);
    }
    if (isFromRequired || hasSpecifiers || hasDeclaration) {
      var _node2$declaration;
      const node2 = node;
      this.checkExport(node2, true, false, !!node2.source);
      if (((_node2$declaration = node2.declaration) == null ? void 0 : _node2$declaration.type) === "ClassDeclaration") {
        this.maybeTakeDecorators(decorators, node2.declaration, node2);
      } else if (decorators) {
        throw this.raise(_parseError.Errors.UnsupportedDecoratorExport, {
          at: node
        });
      }
      return this.finishNode(node2, "ExportNamedDeclaration");
    }
    if (this.eat(65)) {
      const node2 = node;
      const decl = this.parseExportDefaultExpression();
      node2.declaration = decl;
      if (decl.type === "ClassDeclaration") {
        this.maybeTakeDecorators(decorators, decl, node2);
      } else if (decorators) {
        throw this.raise(_parseError.Errors.UnsupportedDecoratorExport, {
          at: node
        });
      }
      this.checkExport(node2, true, true);
      return this.finishNode(node2, "ExportDefaultDeclaration");
    }
    this.unexpected(null, 5);
  }
  eatExportStar(node) {
    return this.eat(55);
  }
  maybeParseExportDefaultSpecifier(node, maybeDefaultIdentifier) {
    if (maybeDefaultIdentifier || this.isExportDefaultSpecifier()) {
      this.expectPlugin("exportDefaultFrom", maybeDefaultIdentifier == null ? void 0 : maybeDefaultIdentifier.loc.start);
      const id = maybeDefaultIdentifier || this.parseIdentifier(true);
      const specifier = this.startNodeAtNode(id);
      specifier.exported = id;
      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.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.nextTokenInLineStart();
    return this.isUnparsedContextual(next, "function");
  }
  parseExportDefaultExpression() {
    const expr = this.startNode();
    if (this.match(68)) {
      this.next();
      return this.parseFunction(expr, ParseFunctionFlag.Declaration | ParseFunctionFlag.NullableId);
    } else if (this.isAsyncFunction()) {
      this.next();
      this.next();
      return this.parseFunction(expr, ParseFunctionFlag.Declaration | ParseFunctionFlag.NullableId | ParseFunctionFlag.Async);
    }
    if (this.match(80)) {
      return this.parseClass(expr, true, true);
    }
    if (this.match(26)) {
      if (this.hasPlugin("decorators") && this.getPluginOption("decorators", "decoratorsBeforeExport") === true) {
        this.raise(_parseError.Errors.DecoratorBeforeExport, {
          at: this.state.startLoc
        });
      }
      return this.parseClass(this.maybeTakeDecorators(this.parseDecorators(false), this.startNode()), true, true);
    }
    if (this.match(75) || this.match(74) || this.isLet()) {
      throw this.raise(_parseError.Errors.UnsupportedDefaultExport, {
        at: this.state.startLoc
      });
    }
    const res = this.parseMaybeAssignAllowIn();
    this.semicolon();
    return res;
  }
  parseExportDeclaration(node) {
    if (this.match(80)) {
      const node = this.parseClass(this.startNode(), true, false);
      return node;
    }
    return this.parseStatementListItem();
  }
  isExportDefaultSpecifier() {
    const {
      type
    } = this.state;
    if ((0, _types.tokenIsIdentifier)(type)) {
      if (type === 95 && !this.state.containsEsc || type === 99) {
        return false;
      }
      if ((type === 128 || type === 127) && !this.state.containsEsc) {
        const {
          type: nextType
        } = this.lookahead();
        if ((0, _types.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 || (0, _types.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);
      this.maybeParseImportAttributes(node);
      this.checkJSONModuleImport(node);
    } 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") === true) {
          this.raise(_parseError.Errors.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(_parseError.Errors.ExportDefaultFromAsIdentifier, {
              at: declaration
            });
          }
        }
      } else if (node.specifiers && node.specifiers.length) {
        for (const specifier of node.specifiers) {
          const {
            exported
          } = specifier;
          const exportName = exported.type === "Identifier" ? exported.name : exported.value;
          this.checkDuplicateExports(specifier, exportName);
          if (!isFrom && specifier.local) {
            const {
              local
            } = specifier;
            if (local.type !== "Identifier") {
              this.raise(_parseError.Errors.ExportBindingIsString, {
                at: specifier,
                localName: local.value,
                exportName
              });
            } 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);
          }
        }
      }
    }
  }
  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, exportName) {
    if (this.exportedIdentifiers.has(exportName)) {
      if (exportName === "default") {
        this.raise(_parseError.Errors.DuplicateDefaultExport, {
          at: node
        });
      } else {
        this.raise(_parseError.Errors.DuplicateExport, {
          at: node,
          exportName
        });
      }
    }
    this.exportedIdentifiers.add(exportName);
  }
  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(128);
      const isString = this.match(131);
      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 = (0, _node.cloneStringLiteral)(node.local);
    } else if (!node.exported) {
      node.exported = (0, _node.cloneIdentifier)(node.local);
    }
    return this.finishNode(node, "ExportSpecifier");
  }
  parseModuleExportName() {
    if (this.match(131)) {
      const result = this.parseStringLiteral(this.state.value);
      const surrogate = result.value.match(loneSurrogate);
      if (surrogate) {
        this.raise(_parseError.Errors.ModuleExportNameHasLoneSurrogate, {
          at: result,
          surrogateCharCode: surrogate[0].charCodeAt(0)
        });
      }
      return result;
    }
    return this.parseIdentifier(true);
  }
  isJSONModuleImport(node) {
    if (node.assertions != null) {
      return node.assertions.some(({
        key,
        value
      }) => {
        return value.value === "json" && (key.type === "Identifier" ? key.name === "type" : key.value === "type");
      });
    }
    return false;
  }
  checkImportReflection(node) {
    if (node.module) {
      var _node$assertions;
      if (node.specifiers.length !== 1 || node.specifiers[0].type !== "ImportDefaultSpecifier") {
        this.raise(_parseError.Errors.ImportReflectionNotBinding, {
          at: node.specifiers[0].loc.start
        });
      }
      if (((_node$assertions = node.assertions) == null ? void 0 : _node$assertions.length) > 0) {
        this.raise(_parseError.Errors.ImportReflectionHasAssertion, {
          at: node.specifiers[0].loc.start
        });
      }
    }
  }
  checkJSONModuleImport(node) {
    if (this.isJSONModuleImport(node) && node.type !== "ExportAllDeclaration") {
      const {
        specifiers
      } = node;
      if (specifiers != null) {
        const nonDefaultNamedSpecifier = specifiers.find(specifier => {
          let imported;
          if (specifier.type === "ExportSpecifier") {
            imported = specifier.local;
          } else if (specifier.type === "ImportSpecifier") {
            imported = specifier.imported;
          }
          if (imported !== undefined) {
            return imported.type === "Identifier" ? imported.name !== "default" : imported.value !== "default";
          }
        });
        if (nonDefaultNamedSpecifier !== undefined) {
          this.raise(_parseError.Errors.ImportJSONBindingNotDefault, {
            at: nonDefaultNamedSpecifier.loc.start
          });
        }
      }
    }
  }
  isPotentialImportPhase(isExport) {
    return !isExport && this.isContextual(125);
  }
  applyImportPhase(node, isExport, phase, loc) {
    if (isExport) {
      ;
      return;
    }
    if (phase === "module") {
      this.expectPlugin("importReflection", loc);
      node.module = true;
    } else if (this.hasPlugin("importReflection")) {
      node.module = false;
    }
  }
  parseMaybeImportPhase(node, isExport) {
    if (!this.isPotentialImportPhase(isExport)) {
      this.applyImportPhase(node, isExport, null);
      return null;
    }
    const phaseIdentifier = this.parseIdentifier(true);
    const {
      type
    } = this.state;
    const isImportPhase = (0, _types.tokenIsKeywordOrIdentifier)(type) ? type !== 97 || this.lookaheadCharCode() === 102 : type !== 12;
    if (isImportPhase) {
      this.resetPreviousIdentifierLeadingComments(phaseIdentifier);
      this.applyImportPhase(node, isExport, phaseIdentifier.name, phaseIdentifier.loc.start);
      return null;
    } else {
      this.applyImportPhase(node, isExport, null);
      return phaseIdentifier;
    }
  }
  isPrecedingIdImportPhase(phase) {
    const {
      type
    } = this.state;
    return (0, _types.tokenIsIdentifier)(type) ? type !== 97 || this.lookaheadCharCode() === 102 : type !== 12;
  }
  parseImport(node) {
    if (this.match(131)) {
      return this.parseImportSourceAndAttributes(node);
    }
    return this.parseImportSpecifiersAndAfter(node, this.parseMaybeImportPhase(node, false));
  }
  parseImportSpecifiersAndAfter(node, maybeDefaultIdentifier) {
    node.specifiers = [];
    const hasDefault = this.maybeParseDefaultImportSpecifier(node, maybeDefaultIdentifier);
    const parseNext = !hasDefault || this.eat(12);
    const hasStar = parseNext && this.maybeParseStarImportSpecifier(node);
    if (parseNext && !hasStar) this.parseNamedImportSpecifiers(node);
    this.expectContextual(97);
    return this.parseImportSourceAndAttributes(node);
  }
  parseImportSourceAndAttributes(node) {
    var _node$specifiers;
    (_node$specifiers = node.specifiers) != null ? _node$specifiers : node.specifiers = [];
    node.source = this.parseImportSource();
    this.maybeParseImportAttributes(node);
    this.checkImportReflection(node);
    this.checkJSONModuleImport(node);
    this.semicolon();
    return this.finishNode(node, "ImportDeclaration");
  }
  parseImportSource() {
    if (!this.match(131)) this.unexpected();
    return this.parseExprAtom();
  }
  parseImportSpecifierLocal(node, specifier, type) {
    specifier.local = this.parseIdentifier();
    node.specifiers.push(this.finishImportSpecifier(specifier, type));
  }
  finishImportSpecifier(specifier, type, bindingType = _scopeflags.BIND_LEXICAL) {
    this.checkLVal(specifier.local, {
      in: {
        type
      },
      binding: bindingType
    });
    return this.finishNode(specifier, type);
  }
  parseImportAttributes() {
    this.expect(5);
    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(_parseError.Errors.ModuleAttributesWithDuplicateKeys, {
          at: this.state.startLoc,
          key: keyName
        });
      }
      attrNames.add(keyName);
      if (this.match(131)) {
        node.key = this.parseStringLiteral(keyName);
      } else {
        node.key = this.parseIdentifier(true);
      }
      this.expect(14);
      if (!this.match(131)) {
        throw this.raise(_parseError.Errors.ModuleAttributeInvalidValue, {
          at: this.state.startLoc
        });
      }
      node.value = this.parseStringLiteral(this.state.value);
      attrs.push(this.finishNode(node, "ImportAttribute"));
    } while (this.eat(12));
    this.expect(8);
    return attrs;
  }
  parseModuleAttributes() {
    const attrs = [];
    const attributes = new Set();
    do {
      const node = this.startNode();
      node.key = this.parseIdentifier(true);
      if (node.key.name !== "type") {
        this.raise(_parseError.Errors.ModuleAttributeDifferentFromType, {
          at: node.key
        });
      }
      if (attributes.has(node.key.name)) {
        this.raise(_parseError.Errors.ModuleAttributesWithDuplicateKeys, {
          at: node.key,
          key: node.key.name
        });
      }
      attributes.add(node.key.name);
      this.expect(14);
      if (!this.match(131)) {
        throw this.raise(_parseError.Errors.ModuleAttributeInvalidValue, {
          at: this.state.startLoc
        });
      }
      node.value = this.parseStringLiteral(this.state.value);
      attrs.push(this.finishNode(node, "ImportAttribute"));
    } while (this.eat(12));
    return attrs;
  }
  maybeParseImportAttributes(node) {
    let attributes;
    let useWith = false;
    if (this.match(76)) {
      if (this.hasPrecedingLineBreak() && this.lookaheadCharCode() === 40) {
        return;
      }
      this.next();
      {
        if (this.hasPlugin("moduleAttributes")) {
          attributes = this.parseModuleAttributes();
        } else {
          this.expectImportAttributesPlugin();
          attributes = this.parseImportAttributes();
        }
      }
      useWith = true;
    } else if (this.isContextual(94) && !this.hasPrecedingLineBreak()) {
      if (this.hasPlugin("importAttributes")) {
        if (this.getPluginOption("importAttributes", "deprecatedAssertSyntax") !== true) {
          this.raise(_parseError.Errors.ImportAttributesUseAssert, {
            at: this.state.startLoc
          });
        }
        this.addExtra(node, "deprecatedAssertSyntax", true);
      } else {
        this.expectOnePlugin(["importAttributes", "importAssertions"]);
      }
      this.next();
      attributes = this.parseImportAttributes();
    } else if (this.hasPlugin("importAttributes") || this.hasPlugin("importAssertions")) {
      attributes = [];
    } else {
      if (this.hasPlugin("moduleAttributes")) {
        attributes = [];
      } else return;
    }
    if (!useWith && this.hasPlugin("importAssertions")) {
      node.assertions = attributes;
    } else {
      node.attributes = attributes;
    }
  }
  maybeParseDefaultImportSpecifier(node, maybeDefaultIdentifier) {
    if (maybeDefaultIdentifier) {
      const specifier = this.startNodeAtNode(maybeDefaultIdentifier);
      specifier.local = maybeDefaultIdentifier;
      node.specifiers.push(this.finishImportSpecifier(specifier, "ImportDefaultSpecifier"));
      return true;
    } else if ((0, _types.tokenIsKeywordOrIdentifier)(this.state.type)) {
      this.parseImportSpecifierLocal(node, this.startNode(), "ImportDefaultSpecifier");
      return true;
    }
    return false;
  }
  maybeParseStarImportSpecifier(node) {
    if (this.match(55)) {
      const specifier = this.startNode();
      this.next();
      this.expectContextual(93);
      this.parseImportSpecifierLocal(node, specifier, "ImportNamespaceSpecifier");
      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(_parseError.Errors.DestructureNamedImport, {
            at: this.state.startLoc
          });
        }
        this.expect(12);
        if (this.eat(8)) break;
      }
      const specifier = this.startNode();
      const importedIsString = this.match(131);
      const isMaybeTypeOnly = this.isContextual(128);
      specifier.imported = this.parseModuleExportName();
      const importSpecifier = this.parseImportSpecifier(specifier, importedIsString, node.importKind === "type" || node.importKind === "typeof", isMaybeTypeOnly, undefined);
      node.specifiers.push(importSpecifier);
    }
  }
  parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, bindingType) {
    if (this.eatContextual(93)) {
      specifier.local = this.parseIdentifier();
    } else {
      const {
        imported
      } = specifier;
      if (importedIsString) {
        throw this.raise(_parseError.Errors.ImportBindingIsString, {
          at: specifier,
          importName: imported.value
        });
      }
      this.checkReservedWord(imported.name, specifier.loc.start, true, true);
      if (!specifier.local) {
        specifier.local = (0, _node.cloneIdentifier)(imported);
      }
    }
    return this.finishImportSpecifier(specifier, "ImportSpecifier", bindingType);
  }
  isThisParam(param) {
    return param.type === "Identifier" && param.name === "this";
  }
}
exports.default = StatementParser;

//# sourceMappingURL=statement.js.map
����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������lib/parser/statement.js.map�������������������������������������������������������������������������0000644�����������������00000573437�15120211212�0011732 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������{"version":3,"names":["_types","require","_expression","_parseError","_identifier","_scopeflags","_util","_productionParameter","_expressionScope","_tokenizer","_location","_node","_lval","loopLabel","kind","switchLabel","ParseFunctionFlag","Expression","Declaration","HangingDeclaration","NullableId","Async","exports","ParseStatementFlag","StatementOnly","AllowImportExport","AllowDeclaration","AllowFunctionDeclaration","AllowLabeledFunction","loneSurrogate","keywordRelationalOperator","babel7CompatTokens","tokens","input","i","length","token","type","loc","start","value","end","hashEndPos","hashEndLoc","createPositionWithColumnOffset","splice","Token","getExportedToken","startLoc","endLoc","tokenIsTemplate","backquoteEnd","backquoteEndLoc","startToken","charCodeAt","templateValue","templateElementEnd","templateElementEndLoc","endToken","slice","StatementParser","ExpressionParser","parseTopLevel","file","program","parseProgram","comments","state","options","finishNode","sourceType","interpreter","parseInterpreterDirective","parseBlockBody","inModule","allowUndeclaredExports","scope","undefinedExports","size","localName","at","Array","from","raise","Errors","ModuleExportUndefined","finishedProgram","finishNodeAt","stmtToDirective","stmt","directive","expression","directiveLiteral","expressionValue","raw","val","addExtra","match","node","startNode","next","isLet","isContextual","hasFollowingBindingAtom","chStartsBindingIdentifier","ch","pos","isIdentifierStart","lastIndex","test","endCh","codePointAtPos","isIdentifierChar","chStartsBindingPattern","nextTokenStart","nextCh","hasInLineFollowingBindingIdentifier","nextTokenInLineStart","startsUsingForOf","containsEsc","lookahead","tokenIsIdentifier","hasFollowingLineBreak","expectPlugin","startsAwaitUsing","isUnparsedContextual","nextTokenInLineStartSince","parseModuleItem","parseStatementLike","parseStatementListItem","annexB","strict","parseStatementOrSloppyAnnexBFunctionDeclaration","allowLabeledFunction","flags","parseStatement","decorators","parseDecorators","parseStatementContent","starttype","allowDeclaration","allowFunctionDeclaration","topLevel","parseBreakContinueStatement","parseDebuggerStatement","parseDoWhileStatement","parseForStatement","lookaheadCharCode","StrictFunction","SloppyFunctionAnnexB","SloppyFunction","parseFunctionStatement","unexpected","parseClass","maybeTakeDecorators","parseIfStatement","parseReturnStatement","parseSwitchStatement","parseThrowStatement","parseTryStatement","isAwaitAllowed","AwaitUsingNotInAsyncContext","UnexpectedLexicalDeclaration","parseVarStatement","inTopLevel","UnexpectedUsingDeclaration","parseWhileStatement","parseWithStatement","parseBlock","parseEmptyStatement","nextTokenCharCode","allowImportExportEverywhere","UnexpectedImportExport","result","parseImport","importKind","sawUnambiguousESM","parseExport","exportKind","assertModuleNodeAllowed","isAsyncFunction","AsyncFunctionInSingleStatementContext","maybeName","expr","parseExpression","eat","parseLabeledStatement","parseExpressionStatement","ImportOutsideModule","decoratorsEnabledBeforeExport","hasPlugin","getPluginOption","maybeDecorators","classNode","exportNode","DecoratorsBeforeAfterExport","unshift","resetStartLocationFromNode","canHaveLeadingDecorator","allowExport","push","parseDecorator","DecoratorExportClass","UnexpectedLeadingDecorator","expectOnePlugin","expect","wrapParenthesis","paramsStartLoc","parseMaybeDecoratorArguments","DecoratorArgumentsOutsideParentheses","parseIdentifier","startNodeAt","object","classScope","usePrivateName","property","parsePrivateName","computed","parseExprSubscripts","startNodeAtNode","callee","arguments","parseCallExpressionArguments","toReferencedList","isBreak","isLineTerminator","label","semicolon","verifyBreakContinue","labels","lab","name","IllegalBreakContinue","parseHeaderExpression","body","withSmartMixTopicForbiddingContext","pop","awaitAt","eatContextual","lastTokStartLoc","enter","SCOPE_OTHER","parseFor","startsWithLet","startsWithAwaitUsing","starsWithUsingDeclaration","isLetOrUsing","initNode","parseVar","init","isForIn","ForInUsing","declarations","parseForIn","startsWithAsync","refExpressionErrors","ExpressionErrors","isForOf","ForOfLet","ForOfAsync","checkDestructuringPrivate","toAssignable","checkLVal","in","checkExpressionErrors","isAsync","isHangingDeclaration","parseFunction","consequent","alternate","prodParam","hasReturn","allowReturnOutsideFunction","IllegalReturn","argument","discriminant","cases","cur","sawDefault","isCase","MultipleDefaultsInSwitch","exit","hasPrecedingLineBreak","NewlineAfterThrow","lastTokEndLoc","parseCatchClauseParam","param","parseBindingAtom","SCOPE_SIMPLE_CATCH","binding","BIND_CATCH_PARAM","block","handler","clause","finalizer","NoCatchOrFinally","allowMissingInitializer","StrictWith","LabelRedeclaration","labelName","tokenIsLoop","statementStart","allowDirectives","createNewLexicalScope","afterBlockParse","strictErrors","clear","isValidDirective","extra","parenthesized","directives","parseBlockOrModuleBlockBody","undefined","oldStrict","hasStrictModeDirective","parsedNonDirective","setStrict","call","update","await","id","ForInOfLoopInitializer","InvalidLhs","ancestor","left","right","parseMaybeAssignAllowIn","isFor","decl","parseVarId","parseMaybeAssignDisallowIn","DeclarationMissingInitializer","BIND_VAR","BIND_LEXICAL","parseAsyncFunctionExpression","hangingDeclaration","isDeclaration","requireId","initFunction","GeneratorInSingleStatementContext","generator","parseFunctionId","oldMaybeInArrowParameters","maybeInArrowParameters","SCOPE_FUNCTION","functionFlags","parseFunctionParams","parseFunctionBodyAndFinish","registerFunctionStatementId","isConstructor","expressionScope","newParameterDeclarationScope","params","parseBindingList","ParseBindingListFlags","IS_FUNCTION_PARAMS","IS_CONSTRUCTOR_PARAMS","declareName","async","treatFunctionsAsVar","BIND_FUNCTION","isStatement","optionalId","parseClassId","parseClassSuper","parseClassBody","superClass","isClassProperty","isClassMethod","isNonstaticConstructor","method","static","key","hadSuperClass","hadConstructor","classBody","DecoratorSemicolon","member","parseClassMember","DecoratorConstructor","TrailingDecorator","parseClassMemberFromModifier","pushClassMethod","prop","parseClassProperty","resetPreviousNodeTrailingComments","isStatic","parseClassStaticBlock","parseClassMemberWithIsStatic","publicMethod","privateMethod","publicProp","privateProp","accessorProp","publicMember","parsePropertyNamePrefixOperator","isPrivateName","parseClassElementName","pushClassPrivateMethod","ConstructorIsGenerator","isPrivate","maybeQuestionTokenStartLoc","parsePostMemberNameModifiers","allowsDirectSuper","DuplicateConstructor","override","OverrideOnConstructor","pushClassPrivateProperty","pushClassProperty","isGenerator","optional","ConstructorIsAsync","ConstructorIsAccessor","checkGetterSetterParams","pushClassAccessorProperty","StaticPrototype","ConstructorClassPrivateField","parsePropertyName","_member$decorators","SCOPE_CLASS","SCOPE_STATIC_BLOCK","SCOPE_SUPER","oldLabels","PARAM","DecoratorStaticBlock","ConstructorClassField","parseClassPrivateProperty","declarePrivateName","getPrivateNameSV","CLASS_ELEMENT_OTHER","parseClassAccessorProperty","parseMethod","CLASS_ELEMENT_STATIC_GETTER","CLASS_ELEMENT_INSTANCE_GETTER","CLASS_ELEMENT_STATIC_SETTER","CLASS_ELEMENT_INSTANCE_SETTER","declareClassPrivateMethodInScope","methodOrProp","parseInitializer","newExpressionScope","bindingType","BIND_CLASS","declareNameFromIdentifier","MissingClassName","maybeDefaultIdentifier","parseMaybeImportPhase","hasDefault","maybeParseExportDefaultSpecifier","parseAfterDefault","hasStar","eatExportStar","hasNamespace","maybeParseExportNamespaceSpecifier","parseAfterNamespace","isFromRequired","UnsupportedDecoratorExport","parseExportFrom","hasSpecifiers","maybeParseExportNamedSpecifiers","hasDeclaration","maybeParseExportDeclaration","_node2$declaration","node2","checkExport","source","declaration","parseExportDefaultExpression","isExportDefaultSpecifier","specifier","exported","specifiers","parseModuleExportName","isTypeExport","parseExportSpecifiers","assertions","shouldParseExportDeclaration","parseExportDeclaration","DecoratorBeforeExport","UnsupportedDefaultExport","res","nextType","hasFrom","nextAfterFrom","nextTokenStartSince","parseImportSource","maybeParseImportAttributes","checkJSONModuleImport","checkNames","isDefault","isFrom","checkDuplicateExports","_declaration$extra","ExportDefaultFromAsIdentifier","exportName","local","ExportBindingIsString","checkReservedWord","checkLocalExport","Error","checkDeclaration","properties","elem","elements","exportedIdentifiers","has","DuplicateDefaultExport","DuplicateExport","add","isInTypeExport","nodes","first","isMaybeTypeOnly","isString","parseExportSpecifier","cloneStringLiteral","cloneIdentifier","parseStringLiteral","surrogate","ModuleExportNameHasLoneSurrogate","surrogateCharCode","isJSONModuleImport","some","checkImportReflection","module","_node$assertions","ImportReflectionNotBinding","ImportReflectionHasAssertion","nonDefaultNamedSpecifier","find","imported","ImportJSONBindingNotDefault","isPotentialImportPhase","isExport","applyImportPhase","phase","phaseIdentifier","isImportPhase","tokenIsKeywordOrIdentifier","resetPreviousIdentifierLeadingComments","isPrecedingIdImportPhase","parseImportSourceAndAttributes","parseImportSpecifiersAndAfter","maybeParseDefaultImportSpecifier","parseNext","maybeParseStarImportSpecifier","parseNamedImportSpecifiers","expectContextual","_node$specifiers","parseExprAtom","parseImportSpecifierLocal","finishImportSpecifier","parseImportAttributes","attrs","attrNames","Set","keyName","ModuleAttributesWithDuplicateKeys","ModuleAttributeInvalidValue","parseModuleAttributes","attributes","ModuleAttributeDifferentFromType","useWith","expectImportAttributesPlugin","ImportAttributesUseAssert","DestructureNamedImport","importedIsString","importSpecifier","parseImportSpecifier","isInTypeOnlyImport","ImportBindingIsString","importName","isThisParam","default"],"sources":["../../src/parser/statement.ts"],"sourcesContent":["import type * as N from \"../types\";\nimport {\n  tokenIsIdentifier,\n  tokenIsKeywordOrIdentifier,\n  tokenIsLoop,\n  tokenIsTemplate,\n  tt,\n  type TokenType,\n  getExportedToken,\n} from \"../tokenizer/types\";\nimport ExpressionParser from \"./expression\";\nimport { Errors } from \"../parse-error\";\nimport { isIdentifierChar, isIdentifierStart } from \"../util/identifier\";\nimport * as charCodes from \"charcodes\";\nimport {\n  BIND_CLASS,\n  BIND_LEXICAL,\n  BIND_VAR,\n  BIND_FUNCTION,\n  SCOPE_CLASS,\n  SCOPE_FUNCTION,\n  SCOPE_OTHER,\n  SCOPE_SIMPLE_CATCH,\n  SCOPE_STATIC_BLOCK,\n  SCOPE_SUPER,\n  CLASS_ELEMENT_OTHER,\n  CLASS_ELEMENT_INSTANCE_GETTER,\n  CLASS_ELEMENT_INSTANCE_SETTER,\n  CLASS_ELEMENT_STATIC_GETTER,\n  CLASS_ELEMENT_STATIC_SETTER,\n  type BindingTypes,\n  BIND_CATCH_PARAM,\n} from \"../util/scopeflags\";\nimport { ExpressionErrors } from \"./util\";\nimport { PARAM, functionFlags } from \"../util/production-parameter\";\nimport {\n  newExpressionScope,\n  newParameterDeclarationScope,\n} from \"../util/expression-scope\";\nimport type { SourceType } from \"../options\";\nimport { Token } from \"../tokenizer\";\nimport type { Position } from \"../util/location\";\nimport { createPositionWithColumnOffset } from \"../util/location\";\nimport { cloneStringLiteral, cloneIdentifier, type Undone } from \"./node\";\nimport type Parser from \"./index\";\nimport { ParseBindingListFlags } from \"./lval\";\n\nconst loopLabel = { kind: \"loop\" } as const,\n  switchLabel = { kind: \"switch\" } as const;\n\nexport const enum ParseFunctionFlag {\n  Expression = 0b0000,\n  Declaration = 0b0001,\n  HangingDeclaration = 0b0010,\n  NullableId = 0b0100,\n  Async = 0b1000,\n}\n\nexport const enum ParseStatementFlag {\n  StatementOnly = 0b0000,\n  AllowImportExport = 0b0001,\n  AllowDeclaration = 0b0010,\n  AllowFunctionDeclaration = 0b0100,\n  AllowLabeledFunction = 0b1000,\n}\n\nconst loneSurrogate = /[\\uD800-\\uDFFF]/u;\n\nconst keywordRelationalOperator = /in(?:stanceof)?/y;\n\n/**\n * Convert tokens for backward Babel 7 compat.\n * tt.privateName => tt.hash + tt.name\n * tt.templateTail => tt.backquote/tt.braceR + tt.template + tt.backquote\n * tt.templateNonTail => tt.backquote/tt.braceR + tt.template + tt.dollarBraceL\n * For performance reasons this routine mutates `tokens`, it is okay\n * here since we execute `parseTopLevel` once for every file.\n */\nfunction babel7CompatTokens(tokens: (Token | N.Comment)[], input: string) {\n  for (let i = 0; i < tokens.length; i++) {\n    const token = tokens[i];\n    const { type } = token;\n    if (typeof type === \"number\") {\n      if (!process.env.BABEL_8_BREAKING) {\n        if (type === tt.privateName) {\n          const { loc, start, value, end } = token;\n          const hashEndPos = start + 1;\n          const hashEndLoc = createPositionWithColumnOffset(loc.start, 1);\n          tokens.splice(\n            i,\n            1,\n            new Token({\n              // @ts-expect-error: hacky way to create token\n              type: getExportedToken(tt.hash),\n              value: \"#\",\n              start: start,\n              end: hashEndPos,\n              startLoc: loc.start,\n              endLoc: hashEndLoc,\n            }),\n            new Token({\n              // @ts-expect-error: hacky way to create token\n              type: getExportedToken(tt.name),\n              value: value,\n              start: hashEndPos,\n              end: end,\n              startLoc: hashEndLoc,\n              endLoc: loc.end,\n            }),\n          );\n          i++;\n          continue;\n        }\n\n        if (tokenIsTemplate(type)) {\n          const { loc, start, value, end } = token;\n          const backquoteEnd = start + 1;\n          const backquoteEndLoc = createPositionWithColumnOffset(loc.start, 1);\n          let startToken;\n          if (input.charCodeAt(start) === charCodes.graveAccent) {\n            startToken = new Token({\n              // @ts-expect-error: hacky way to create token\n              type: getExportedToken(tt.backQuote),\n              value: \"`\",\n              start: start,\n              end: backquoteEnd,\n              startLoc: loc.start,\n              endLoc: backquoteEndLoc,\n            });\n          } else {\n            startToken = new Token({\n              // @ts-expect-error: hacky way to create token\n              type: getExportedToken(tt.braceR),\n              value: \"}\",\n              start: start,\n              end: backquoteEnd,\n              startLoc: loc.start,\n              endLoc: backquoteEndLoc,\n            });\n          }\n          let templateValue,\n            templateElementEnd,\n            templateElementEndLoc,\n            endToken;\n          if (type === tt.templateTail) {\n            // ends with '`'\n            templateElementEnd = end - 1;\n            templateElementEndLoc = createPositionWithColumnOffset(loc.end, -1);\n            templateValue = value === null ? null : value.slice(1, -1);\n            endToken = new Token({\n              // @ts-expect-error: hacky way to create token\n              type: getExportedToken(tt.backQuote),\n              value: \"`\",\n              start: templateElementEnd,\n              end: end,\n              startLoc: templateElementEndLoc,\n              endLoc: loc.end,\n            });\n          } else {\n            // ends with `${`\n            templateElementEnd = end - 2;\n            templateElementEndLoc = createPositionWithColumnOffset(loc.end, -2);\n            templateValue = value === null ? null : value.slice(1, -2);\n            endToken = new Token({\n              // @ts-expect-error: hacky way to create token\n              type: getExportedToken(tt.dollarBraceL),\n              value: \"${\",\n              start: templateElementEnd,\n              end: end,\n              startLoc: templateElementEndLoc,\n              endLoc: loc.end,\n            });\n          }\n          tokens.splice(\n            i,\n            1,\n            startToken,\n            new Token({\n              // @ts-expect-error: hacky way to create token\n              type: getExportedToken(tt.template),\n              value: templateValue,\n              start: backquoteEnd,\n              end: templateElementEnd,\n              startLoc: backquoteEndLoc,\n              endLoc: templateElementEndLoc,\n            }),\n            endToken,\n          );\n          i += 2;\n          continue;\n        }\n      }\n      // @ts-expect-error: we manipulate `token` for performance reasons\n      token.type = getExportedToken(type);\n    }\n  }\n  return tokens;\n}\nexport default abstract class StatementParser extends ExpressionParser {\n  // ### Statement parsing\n\n  // Parse a program. Initializes the parser, reads any number of\n  // statements, and wraps them in a Program node.  Optionally takes a\n  // `program` argument.  If present, the statements will be appended\n  // to its body instead of creating a new node.\n\n  parseTopLevel(this: Parser, file: N.File, program: N.Program): N.File {\n    file.program = this.parseProgram(program);\n    file.comments = this.state.comments;\n\n    if (this.options.tokens) {\n      file.tokens = babel7CompatTokens(this.tokens, this.input);\n    }\n\n    return this.finishNode(file, \"File\");\n  }\n\n  parseProgram(\n    this: Parser,\n    program: Undone<N.Program>,\n    end: TokenType = tt.eof,\n    sourceType: SourceType = this.options.sourceType,\n  ): N.Program {\n    program.sourceType = sourceType;\n    program.interpreter = this.parseInterpreterDirective();\n    this.parseBlockBody(program, true, true, end);\n    if (\n      this.inModule &&\n      !this.options.allowUndeclaredExports &&\n      this.scope.undefinedExports.size > 0\n    ) {\n      for (const [localName, at] of Array.from(this.scope.undefinedExports)) {\n        this.raise(Errors.ModuleExportUndefined, { at, localName });\n      }\n    }\n    let finishedProgram: N.Program;\n    if (end === tt.eof) {\n      // finish at eof for top level program\n      finishedProgram = this.finishNode(program, \"Program\");\n    } else {\n      // finish immediately before the end token\n      finishedProgram = this.finishNodeAt(\n        program,\n        \"Program\",\n        createPositionWithColumnOffset(this.state.startLoc, -1),\n      );\n    }\n    return finishedProgram;\n  }\n\n  /**\n   * cast a Statement to a Directive. This method mutates input statement.\n   */\n  stmtToDirective(stmt: N.Statement): N.Directive {\n    const directive = stmt as any;\n    directive.type = \"Directive\";\n    directive.value = directive.expression;\n    delete directive.expression;\n\n    const directiveLiteral = directive.value;\n    const expressionValue = directiveLiteral.value;\n    const raw = this.input.slice(directiveLiteral.start, directiveLiteral.end);\n    const val = (directiveLiteral.value = raw.slice(1, -1)); // remove quotes\n\n    this.addExtra(directiveLiteral, \"raw\", raw);\n    this.addExtra(directiveLiteral, \"rawValue\", val);\n    this.addExtra(directiveLiteral, \"expressionValue\", expressionValue);\n\n    directiveLiteral.type = \"DirectiveLiteral\";\n\n    return directive;\n  }\n\n  parseInterpreterDirective(): N.InterpreterDirective | null {\n    if (!this.match(tt.interpreterDirective)) {\n      return null;\n    }\n\n    const node = this.startNode<N.InterpreterDirective>();\n    node.value = this.state.value;\n    this.next();\n    return this.finishNode(node, \"InterpreterDirective\");\n  }\n\n  isLet(): boolean {\n    if (!this.isContextual(tt._let)) {\n      return false;\n    }\n    return this.hasFollowingBindingAtom();\n  }\n\n  chStartsBindingIdentifier(ch: number, pos: number) {\n    if (isIdentifierStart(ch)) {\n      keywordRelationalOperator.lastIndex = pos;\n      if (keywordRelationalOperator.test(this.input)) {\n        // We have seen `in` or `instanceof` so far, now check if the identifier\n        // ends here\n        const endCh = this.codePointAtPos(keywordRelationalOperator.lastIndex);\n        if (!isIdentifierChar(endCh) && endCh !== charCodes.backslash) {\n          return false;\n        }\n      }\n      return true;\n    } else if (ch === charCodes.backslash) {\n      return true;\n    } else {\n      return false;\n    }\n  }\n\n  chStartsBindingPattern(ch: number) {\n    return (\n      ch === charCodes.leftSquareBracket || ch === charCodes.leftCurlyBrace\n    );\n  }\n\n  /**\n   * Assuming we have seen a contextual `let` and declaration is allowed, check if it\n   * starts a variable declaration so that it should be interpreted as a keyword.\n   */\n  hasFollowingBindingAtom(): boolean {\n    const next = this.nextTokenStart();\n    const nextCh = this.codePointAtPos(next);\n    return (\n      this.chStartsBindingPattern(nextCh) ||\n      this.chStartsBindingIdentifier(nextCh, next)\n    );\n  }\n\n  /**\n   * Assuming we have seen a contextual `using` and declaration is allowed, check if it\n   * starts a variable declaration in the same line so that it should be interpreted as\n   * a keyword.\n   */\n  hasInLineFollowingBindingIdentifier(): boolean {\n    const next = this.nextTokenInLineStart();\n    const nextCh = this.codePointAtPos(next);\n    return this.chStartsBindingIdentifier(nextCh, next);\n  }\n\n  startsUsingForOf(): boolean {\n    const { type, containsEsc } = this.lookahead();\n    if (type === tt._of && !containsEsc) {\n      // `using of` must start a for-lhs-of statement\n      return false;\n    } else if (tokenIsIdentifier(type) && !this.hasFollowingLineBreak()) {\n      this.expectPlugin(\"explicitResourceManagement\");\n      return true;\n    }\n  }\n\n  startsAwaitUsing(): boolean {\n    let next = this.nextTokenInLineStart();\n    if (this.isUnparsedContextual(next, \"using\")) {\n      next = this.nextTokenInLineStartSince(next + 5);\n      const nextCh = this.codePointAtPos(next);\n      if (this.chStartsBindingIdentifier(nextCh, next)) {\n        this.expectPlugin(\"explicitResourceManagement\");\n        return true;\n      }\n    }\n    return false;\n  }\n\n  // https://tc39.es/ecma262/#prod-ModuleItem\n  parseModuleItem(this: Parser) {\n    return this.parseStatementLike(\n      ParseStatementFlag.AllowImportExport |\n        ParseStatementFlag.AllowDeclaration |\n        ParseStatementFlag.AllowFunctionDeclaration |\n        // This function is actually also used to parse StatementItems,\n        // which with Annex B enabled allows labeled functions.\n        ParseStatementFlag.AllowLabeledFunction,\n    );\n  }\n\n  // https://tc39.es/ecma262/#prod-StatementListItem\n  parseStatementListItem(this: Parser) {\n    return this.parseStatementLike(\n      ParseStatementFlag.AllowDeclaration |\n        ParseStatementFlag.AllowFunctionDeclaration |\n        (!this.options.annexB || this.state.strict\n          ? 0\n          : ParseStatementFlag.AllowLabeledFunction),\n    );\n  }\n\n  parseStatementOrSloppyAnnexBFunctionDeclaration(\n    this: Parser,\n    allowLabeledFunction: boolean = false,\n  ) {\n    let flags: ParseStatementFlag = ParseStatementFlag.StatementOnly;\n    if (this.options.annexB && !this.state.strict) {\n      flags |= ParseStatementFlag.AllowFunctionDeclaration;\n      if (allowLabeledFunction) {\n        flags |= ParseStatementFlag.AllowLabeledFunction;\n      }\n    }\n    return this.parseStatementLike(flags);\n  }\n\n  // Parse a single statement.\n  //\n  // If expecting a statement and finding a slash operator, parse a\n  // regular expression literal. This is to handle cases like\n  // `if (foo) /blah/.exec(foo)`, where looking at the previous token\n  // does not help.\n  // https://tc39.es/ecma262/#prod-Statement\n  parseStatement(this: Parser) {\n    return this.parseStatementLike(ParseStatementFlag.StatementOnly);\n  }\n\n  // ImportDeclaration and ExportDeclaration are also handled here so we can throw recoverable errors\n  // when they are not at the top level\n  parseStatementLike(\n    this: Parser,\n    flags: ParseStatementFlag,\n  ):\n    | N.Statement\n    | N.Declaration\n    | N.ImportDeclaration\n    | N.ExportDefaultDeclaration\n    | N.ExportNamedDeclaration\n    | N.ExportAllDeclaration {\n    let decorators: N.Decorator[] | null = null;\n\n    if (this.match(tt.at)) {\n      decorators = this.parseDecorators(true);\n    }\n    return this.parseStatementContent(flags, decorators);\n  }\n\n  parseStatementContent(\n    this: Parser,\n    flags: ParseStatementFlag,\n    decorators?: N.Decorator[] | null,\n  ): N.Statement {\n    const starttype = this.state.type;\n    const node = this.startNode();\n    const allowDeclaration = !!(flags & ParseStatementFlag.AllowDeclaration);\n    const allowFunctionDeclaration = !!(\n      flags & ParseStatementFlag.AllowFunctionDeclaration\n    );\n    const topLevel = flags & ParseStatementFlag.AllowImportExport;\n\n    // Most types of statements are recognized by the keyword they\n    // start with. Many are trivial to parse, some require a bit of\n    // complexity.\n\n    switch (starttype) {\n      case tt._break:\n        return this.parseBreakContinueStatement(node, /* isBreak */ true);\n      case tt._continue:\n        return this.parseBreakContinueStatement(node, /* isBreak */ false);\n      case tt._debugger:\n        return this.parseDebuggerStatement(node as Undone<N.DebuggerStatement>);\n      case tt._do:\n        return this.parseDoWhileStatement(node as Undone<N.DoWhileStatement>);\n      case tt._for:\n        return this.parseForStatement(node as Undone<N.ForStatement>);\n      case tt._function:\n        if (this.lookaheadCharCode() === charCodes.dot) break;\n        if (!allowFunctionDeclaration) {\n          this.raise(\n            this.state.strict\n              ? Errors.StrictFunction\n              : this.options.annexB\n              ? Errors.SloppyFunctionAnnexB\n              : Errors.SloppyFunction,\n            { at: this.state.startLoc },\n          );\n        }\n        return this.parseFunctionStatement(\n          node as Undone<N.FunctionDeclaration>,\n          false,\n          !allowDeclaration && allowFunctionDeclaration,\n        );\n      case tt._class:\n        if (!allowDeclaration) this.unexpected();\n        return this.parseClass(\n          this.maybeTakeDecorators(\n            decorators,\n            node as Undone<N.ClassDeclaration>,\n          ),\n          true,\n        );\n\n      case tt._if:\n        return this.parseIfStatement(node as Undone<N.IfStatement>);\n      case tt._return:\n        return this.parseReturnStatement(node as Undone<N.ReturnStatement>);\n      case tt._switch:\n        return this.parseSwitchStatement(node as Undone<N.SwitchStatement>);\n      case tt._throw:\n        return this.parseThrowStatement(node as Undone<N.ThrowStatement>);\n      case tt._try:\n        return this.parseTryStatement(node as Undone<N.TryStatement>);\n\n      case tt._await:\n        // [+Await] await [no LineTerminator here] using [no LineTerminator here] BindingList[+Using]\n        if (!this.state.containsEsc && this.startsAwaitUsing()) {\n          if (!this.isAwaitAllowed()) {\n            this.raise(Errors.AwaitUsingNotInAsyncContext, { at: node });\n          } else if (!allowDeclaration) {\n            this.raise(Errors.UnexpectedLexicalDeclaration, {\n              at: node,\n            });\n          }\n          this.next(); // eat 'await'\n          return this.parseVarStatement(\n            node as Undone<N.VariableDeclaration>,\n            \"await using\",\n          );\n        }\n        break;\n      case tt._using:\n        // using [no LineTerminator here] BindingList[+Using]\n        if (\n          this.state.containsEsc ||\n          !this.hasInLineFollowingBindingIdentifier()\n        ) {\n          break;\n        }\n        this.expectPlugin(\"explicitResourceManagement\");\n        if (!this.scope.inModule && this.scope.inTopLevel) {\n          this.raise(Errors.UnexpectedUsingDeclaration, {\n            at: this.state.startLoc,\n          });\n        } else if (!allowDeclaration) {\n          this.raise(Errors.UnexpectedLexicalDeclaration, {\n            at: this.state.startLoc,\n          });\n        }\n        return this.parseVarStatement(\n          node as Undone<N.VariableDeclaration>,\n          \"using\",\n        );\n      case tt._let: {\n        if (this.state.containsEsc) {\n          break;\n        }\n        // `let [` is an explicit negative lookahead for\n        // ExpressionStatement, so special-case it first.\n        const next = this.nextTokenStart();\n        const nextCh = this.codePointAtPos(next);\n        if (nextCh !== charCodes.leftSquareBracket) {\n          if (!allowDeclaration && this.hasFollowingLineBreak()) break;\n          if (\n            !this.chStartsBindingIdentifier(nextCh, next) &&\n            nextCh !== charCodes.leftCurlyBrace\n          ) {\n            break;\n          }\n        }\n      }\n      // fall through\n      case tt._const: {\n        if (!allowDeclaration) {\n          this.raise(Errors.UnexpectedLexicalDeclaration, {\n            at: this.state.startLoc,\n          });\n        }\n      }\n      // fall through\n      case tt._var: {\n        const kind = this.state.value;\n        return this.parseVarStatement(\n          node as Undone<N.VariableDeclaration>,\n          kind,\n        );\n      }\n      case tt._while:\n        return this.parseWhileStatement(node as Undone<N.WhileStatement>);\n      case tt._with:\n        return this.parseWithStatement(node as Undone<N.WithStatement>);\n      case tt.braceL:\n        return this.parseBlock();\n      case tt.semi:\n        return this.parseEmptyStatement(node as Undone<N.EmptyStatement>);\n      case tt._import: {\n        const nextTokenCharCode = this.lookaheadCharCode();\n        if (\n          nextTokenCharCode === charCodes.leftParenthesis || // import()\n          nextTokenCharCode === charCodes.dot // import.meta\n        ) {\n          break;\n        }\n      }\n      // fall through\n      case tt._export: {\n        if (!this.options.allowImportExportEverywhere && !topLevel) {\n          this.raise(Errors.UnexpectedImportExport, {\n            at: this.state.startLoc,\n          });\n        }\n\n        this.next(); // eat `import`/`export`\n\n        let result;\n        if (starttype === tt._import) {\n          result = this.parseImport(node as Undone<N.ImportDeclaration>);\n\n          if (\n            result.type === \"ImportDeclaration\" &&\n            (!result.importKind || result.importKind === \"value\")\n          ) {\n            this.sawUnambiguousESM = true;\n          }\n        } else {\n          result = this.parseExport(\n            node as Undone<\n              | N.ExportAllDeclaration\n              | N.ExportDefaultDeclaration\n              | N.ExportDefaultDeclaration\n            >,\n            decorators,\n          );\n\n          if (\n            (result.type === \"ExportNamedDeclaration\" &&\n              (!result.exportKind || result.exportKind === \"value\")) ||\n            (result.type === \"ExportAllDeclaration\" &&\n              (!result.exportKind || result.exportKind === \"value\")) ||\n            result.type === \"ExportDefaultDeclaration\"\n          ) {\n            this.sawUnambiguousESM = true;\n          }\n        }\n\n        this.assertModuleNodeAllowed(result);\n\n        return result;\n      }\n\n      default: {\n        if (this.isAsyncFunction()) {\n          if (!allowDeclaration) {\n            this.raise(Errors.AsyncFunctionInSingleStatementContext, {\n              at: this.state.startLoc,\n            });\n          }\n          this.next(); // eat 'async'\n          return this.parseFunctionStatement(\n            node as Undone<N.FunctionDeclaration>,\n            true,\n            !allowDeclaration && allowFunctionDeclaration,\n          );\n        }\n      }\n    }\n\n    // If the statement does not start with a statement keyword or a\n    // brace, it's an ExpressionStatement or LabeledStatement. We\n    // simply start parsing an expression, and afterwards, if the\n    // next token is a colon and the expression was a simple\n    // Identifier node, we switch to interpreting it as a label.\n    const maybeName = this.state.value;\n    const expr = this.parseExpression();\n\n    if (\n      tokenIsIdentifier(starttype) &&\n      expr.type === \"Identifier\" &&\n      this.eat(tt.colon)\n    ) {\n      return this.parseLabeledStatement(\n        node as Undone<N.LabeledStatement>,\n        maybeName,\n        // @ts-expect-error migrate to Babel types\n        expr,\n        flags,\n      );\n    } else {\n      return this.parseExpressionStatement(\n        node as Undone<N.ExpressionStatement>,\n        expr,\n        decorators,\n      );\n    }\n  }\n\n  assertModuleNodeAllowed(node: N.Node): void {\n    if (!this.options.allowImportExportEverywhere && !this.inModule) {\n      this.raise(Errors.ImportOutsideModule, { at: node });\n    }\n  }\n\n  decoratorsEnabledBeforeExport(): boolean {\n    if (this.hasPlugin(\"decorators-legacy\")) return true;\n    return (\n      this.hasPlugin(\"decorators\") &&\n      this.getPluginOption(\"decorators\", \"decoratorsBeforeExport\") !== false\n    );\n  }\n\n  // Attach the decorators to the given class.\n  // NOTE: This method changes the .start location of the class, and thus\n  // can affect comment attachment. Calling it before or after finalizing\n  // the class node (and thus finalizing its comments) changes how comments\n  // before the `class` keyword or before the final .start location of the\n  // class are attached.\n  maybeTakeDecorators<T extends Undone<N.Class>>(\n    maybeDecorators: N.Decorator[] | null,\n    classNode: T,\n    exportNode?: Undone<N.ExportDefaultDeclaration | N.ExportNamedDeclaration>,\n  ): T {\n    if (maybeDecorators) {\n      if (classNode.decorators && classNode.decorators.length > 0) {\n        // Note: decorators attachment is only attempred multiple times\n        // when the class is part of an export declaration.\n        if (\n          typeof this.getPluginOption(\n            \"decorators\",\n            \"decoratorsBeforeExport\",\n          ) !== \"boolean\"\n        ) {\n          // If `decoratorsBeforeExport` was set to `true` or `false`, we\n          // already threw an error about decorators not being in a valid\n          // position.\n          this.raise(Errors.DecoratorsBeforeAfterExport, {\n            at: classNode.decorators[0],\n          });\n        }\n        classNode.decorators.unshift(...maybeDecorators);\n      } else {\n        classNode.decorators = maybeDecorators;\n      }\n      this.resetStartLocationFromNode(classNode, maybeDecorators[0]);\n      if (exportNode) this.resetStartLocationFromNode(exportNode, classNode);\n    }\n    return classNode;\n  }\n\n  canHaveLeadingDecorator(): boolean {\n    return this.match(tt._class);\n  }\n\n  parseDecorators(this: Parser, allowExport?: boolean): N.Decorator[] {\n    const decorators = [];\n    do {\n      decorators.push(this.parseDecorator());\n    } while (this.match(tt.at));\n\n    if (this.match(tt._export)) {\n      if (!allowExport) {\n        this.unexpected();\n      }\n\n      if (!this.decoratorsEnabledBeforeExport()) {\n        this.raise(Errors.DecoratorExportClass, { at: this.state.startLoc });\n      }\n    } else if (!this.canHaveLeadingDecorator()) {\n      throw this.raise(Errors.UnexpectedLeadingDecorator, {\n        at: this.state.startLoc,\n      });\n    }\n\n    return decorators;\n  }\n\n  parseDecorator(this: Parser): N.Decorator {\n    this.expectOnePlugin([\"decorators\", \"decorators-legacy\"]);\n\n    const node = this.startNode<N.Decorator>();\n    this.next();\n\n    if (this.hasPlugin(\"decorators\")) {\n      const startLoc = this.state.startLoc;\n      let expr: N.Expression;\n\n      if (this.match(tt.parenL)) {\n        const startLoc = this.state.startLoc;\n        this.next(); // eat '('\n        expr = this.parseExpression();\n        this.expect(tt.parenR);\n        expr = this.wrapParenthesis(startLoc, expr);\n\n        const paramsStartLoc = this.state.startLoc;\n        node.expression = this.parseMaybeDecoratorArguments(expr);\n        if (\n          this.getPluginOption(\"decorators\", \"allowCallParenthesized\") ===\n            false &&\n          node.expression !== expr\n        ) {\n          this.raise(Errors.DecoratorArgumentsOutsideParentheses, {\n            at: paramsStartLoc,\n          });\n        }\n      } else {\n        expr = this.parseIdentifier(false);\n\n        while (this.eat(tt.dot)) {\n          const node = this.startNodeAt(startLoc);\n          node.object = expr;\n          if (this.match(tt.privateName)) {\n            this.classScope.usePrivateName(\n              this.state.value,\n              this.state.startLoc,\n            );\n            node.property = this.parsePrivateName();\n          } else {\n            node.property = this.parseIdentifier(true);\n          }\n          node.computed = false;\n          expr = this.finishNode(node, \"MemberExpression\");\n        }\n\n        node.expression = this.parseMaybeDecoratorArguments(expr);\n      }\n    } else {\n      node.expression = this.parseExprSubscripts();\n    }\n    return this.finishNode(node, \"Decorator\");\n  }\n\n  parseMaybeDecoratorArguments(this: Parser, expr: N.Expression): N.Expression {\n    if (this.eat(tt.parenL)) {\n      const node = this.startNodeAtNode(expr);\n      node.callee = expr;\n      node.arguments = this.parseCallExpressionArguments(tt.parenR, false);\n      this.toReferencedList(node.arguments);\n      return this.finishNode(node, \"CallExpression\");\n    }\n\n    return expr;\n  }\n\n  parseBreakContinueStatement(\n    node: Undone<N.Node>,\n    isBreak: true,\n  ): N.BreakStatement;\n  parseBreakContinueStatement(\n    node: Undone<N.Node>,\n    isBreak: false,\n  ): N.ContinueStatement;\n  parseBreakContinueStatement(\n    node: Undone<N.BreakStatement | N.ContinueStatement>,\n    isBreak: boolean,\n  ): N.BreakStatement | N.ContinueStatement {\n    this.next();\n\n    if (this.isLineTerminator()) {\n      node.label = null;\n    } else {\n      node.label = this.parseIdentifier();\n      this.semicolon();\n    }\n\n    this.verifyBreakContinue(node, isBreak);\n\n    return this.finishNode(\n      node,\n      isBreak ? \"BreakStatement\" : \"ContinueStatement\",\n    );\n  }\n\n  verifyBreakContinue(\n    node: Undone<N.BreakStatement | N.ContinueStatement>,\n    isBreak: boolean,\n  ) {\n    let i;\n    for (i = 0; i < this.state.labels.length; ++i) {\n      const lab = this.state.labels[i];\n      if (node.label == null || lab.name === node.label.name) {\n        if (lab.kind != null && (isBreak || lab.kind === \"loop\")) break;\n        if (node.label && isBreak) break;\n      }\n    }\n    if (i === this.state.labels.length) {\n      const type = isBreak ? \"BreakStatement\" : \"ContinueStatement\";\n      this.raise(Errors.IllegalBreakContinue, { at: node, type });\n    }\n  }\n\n  parseDebuggerStatement(\n    node: Undone<N.DebuggerStatement>,\n  ): N.DebuggerStatement {\n    this.next();\n    this.semicolon();\n    return this.finishNode(node, \"DebuggerStatement\");\n  }\n\n  parseHeaderExpression(this: Parser): N.Expression {\n    this.expect(tt.parenL);\n    const val = this.parseExpression();\n    this.expect(tt.parenR);\n    return val;\n  }\n\n  // https://tc39.es/ecma262/#prod-DoWhileStatement\n  parseDoWhileStatement(\n    this: Parser,\n    node: Undone<N.DoWhileStatement>,\n  ): N.DoWhileStatement {\n    this.next();\n    this.state.labels.push(loopLabel);\n\n    // Parse the loop body's body.\n    node.body =\n      // For the smartPipelines plugin: Disable topic references from outer\n      // contexts within the loop body. They are permitted in test expressions,\n      // outside of the loop body.\n      this.withSmartMixTopicForbiddingContext(() =>\n        // Parse the loop body's body.\n        this.parseStatement(),\n      );\n\n    this.state.labels.pop();\n\n    this.expect(tt._while);\n    node.test = this.parseHeaderExpression();\n    this.eat(tt.semi);\n    return this.finishNode(node, \"DoWhileStatement\");\n  }\n\n  // Disambiguating between a `for` and a `for`/`in` or `for`/`of`\n  // loop is non-trivial. Basically, we have to parse the init `var`\n  // statement or expression, disallowing the `in` operator (see\n  // the second parameter to `parseExpression`), and then check\n  // whether the next token is `in` or `of`. When there is no init\n  // part (semicolon immediately after the opening parenthesis), it\n  // is a regular `for` loop.\n\n  parseForStatement(\n    this: Parser,\n    node: Undone<N.ForStatement | N.ForInOf>,\n  ): N.ForLike {\n    this.next();\n    this.state.labels.push(loopLabel);\n\n    let awaitAt = null;\n\n    if (this.isAwaitAllowed() && this.eatContextual(tt._await)) {\n      awaitAt = this.state.lastTokStartLoc;\n    }\n    this.scope.enter(SCOPE_OTHER);\n    this.expect(tt.parenL);\n\n    if (this.match(tt.semi)) {\n      if (awaitAt !== null) {\n        this.unexpected(awaitAt);\n      }\n      return this.parseFor(node as Undone<N.ForStatement>, null);\n    }\n\n    const startsWithLet = this.isContextual(tt._let);\n    {\n      const startsWithAwaitUsing =\n        this.isContextual(tt._await) && this.startsAwaitUsing();\n      const starsWithUsingDeclaration =\n        startsWithAwaitUsing ||\n        (this.isContextual(tt._using) && this.startsUsingForOf());\n      const isLetOrUsing =\n        (startsWithLet && this.hasFollowingBindingAtom()) ||\n        starsWithUsingDeclaration;\n\n      if (this.match(tt._var) || this.match(tt._const) || isLetOrUsing) {\n        const initNode = this.startNode<N.VariableDeclaration>();\n        let kind;\n        if (startsWithAwaitUsing) {\n          kind = \"await using\";\n          if (!this.isAwaitAllowed()) {\n            this.raise(Errors.AwaitUsingNotInAsyncContext, {\n              at: this.state.startLoc,\n            });\n          }\n          this.next(); // eat 'await'\n        } else {\n          kind = this.state.value;\n        }\n        this.next();\n        this.parseVar(initNode, true, kind);\n        const init = this.finishNode(initNode, \"VariableDeclaration\");\n\n        const isForIn = this.match(tt._in);\n        if (isForIn && starsWithUsingDeclaration) {\n          this.raise(Errors.ForInUsing, { at: init });\n        }\n        if (\n          (isForIn || this.isContextual(tt._of)) &&\n          init.declarations.length === 1\n        ) {\n          return this.parseForIn(node as Undone<N.ForInOf>, init, awaitAt);\n        }\n        if (awaitAt !== null) {\n          this.unexpected(awaitAt);\n        }\n        return this.parseFor(node as Undone<N.ForStatement>, init);\n      }\n    }\n\n    // Check whether the first token is possibly a contextual keyword, so that\n    // we can forbid `for (async of` if this turns out to be a for-of loop.\n    const startsWithAsync = this.isContextual(tt._async);\n\n    const refExpressionErrors = new ExpressionErrors();\n    const init = this.parseExpression(true, refExpressionErrors);\n    const isForOf = this.isContextual(tt._of);\n    if (isForOf) {\n      // Check for leading tokens that are forbidden in for-of loops:\n      if (startsWithLet) {\n        this.raise(Errors.ForOfLet, { at: init });\n      }\n\n      if (\n        // `for await (async of []);` is allowed.\n        awaitAt === null &&\n        startsWithAsync &&\n        init.type === \"Identifier\"\n      ) {\n        // This catches the case where the `async` in `for (async of` was\n        // parsed as an identifier. If it was parsed as the start of an async\n        // arrow function (e.g. `for (async of => {} of []);`), the LVal check\n        // further down will raise a more appropriate error.\n        this.raise(Errors.ForOfAsync, { at: init });\n      }\n    }\n    if (isForOf || this.match(tt._in)) {\n      this.checkDestructuringPrivate(refExpressionErrors);\n      this.toAssignable(init, /* isLHS */ true);\n      const type = isForOf ? \"ForOfStatement\" : \"ForInStatement\";\n      this.checkLVal(init, { in: { type } });\n      return this.parseForIn(\n        node as Undone<N.ForInStatement | N.ForOfStatement>,\n        // @ts-expect-error init has been transformed to an assignable\n        init,\n        awaitAt,\n      );\n    } else {\n      this.checkExpressionErrors(refExpressionErrors, true);\n    }\n    if (awaitAt !== null) {\n      this.unexpected(awaitAt);\n    }\n    return this.parseFor(node as Undone<N.ForStatement>, init);\n  }\n\n  // https://tc39.es/ecma262/#prod-HoistableDeclaration\n  parseFunctionStatement(\n    this: Parser,\n    node: Undone<N.FunctionDeclaration>,\n    isAsync: boolean,\n    isHangingDeclaration: boolean,\n  ): N.FunctionDeclaration {\n    this.next(); // eat 'function'\n    return this.parseFunction(\n      node,\n      ParseFunctionFlag.Declaration |\n        (isHangingDeclaration ? ParseFunctionFlag.HangingDeclaration : 0) |\n        (isAsync ? ParseFunctionFlag.Async : 0),\n    );\n  }\n\n  // https://tc39.es/ecma262/#prod-IfStatement\n  parseIfStatement(this: Parser, node: Undone<N.IfStatement>) {\n    this.next();\n    node.test = this.parseHeaderExpression();\n    // Annex B.3.3\n    // https://tc39.es/ecma262/#sec-functiondeclarations-in-ifstatement-statement-clauses\n    node.consequent = this.parseStatementOrSloppyAnnexBFunctionDeclaration();\n    node.alternate = this.eat(tt._else)\n      ? this.parseStatementOrSloppyAnnexBFunctionDeclaration()\n      : null;\n    return this.finishNode(node, \"IfStatement\");\n  }\n\n  parseReturnStatement(this: Parser, node: Undone<N.ReturnStatement>) {\n    if (!this.prodParam.hasReturn && !this.options.allowReturnOutsideFunction) {\n      this.raise(Errors.IllegalReturn, { at: this.state.startLoc });\n    }\n\n    this.next();\n\n    // In `return` (and `break`/`continue`), the keywords with\n    // optional arguments, we eagerly look for a semicolon or the\n    // possibility to insert one.\n\n    if (this.isLineTerminator()) {\n      node.argument = null;\n    } else {\n      node.argument = this.parseExpression();\n      this.semicolon();\n    }\n\n    return this.finishNode(node, \"ReturnStatement\");\n  }\n\n  // https://tc39.es/ecma262/#prod-SwitchStatement\n  parseSwitchStatement(this: Parser, node: Undone<N.SwitchStatement>) {\n    this.next();\n    node.discriminant = this.parseHeaderExpression();\n    const cases: N.SwitchStatement[\"cases\"] = (node.cases = []);\n    this.expect(tt.braceL);\n    this.state.labels.push(switchLabel);\n    this.scope.enter(SCOPE_OTHER);\n\n    // Statements under must be grouped (by label) in SwitchCase\n    // nodes. `cur` is used to keep the node that we are currently\n    // adding statements to.\n\n    let cur;\n    for (let sawDefault; !this.match(tt.braceR); ) {\n      if (this.match(tt._case) || this.match(tt._default)) {\n        const isCase = this.match(tt._case);\n        if (cur) this.finishNode(cur, \"SwitchCase\");\n        // @ts-expect-error Fixme\n        cases.push((cur = this.startNode()));\n        cur.consequent = [];\n        this.next();\n        if (isCase) {\n          cur.test = this.parseExpression();\n        } else {\n          if (sawDefault) {\n            this.raise(Errors.MultipleDefaultsInSwitch, {\n              at: this.state.lastTokStartLoc,\n            });\n          }\n          sawDefault = true;\n          cur.test = null;\n        }\n        this.expect(tt.colon);\n      } else {\n        if (cur) {\n          cur.consequent.push(this.parseStatementListItem());\n        } else {\n          this.unexpected();\n        }\n      }\n    }\n    this.scope.exit();\n    if (cur) this.finishNode(cur, \"SwitchCase\");\n    this.next(); // Closing brace\n    this.state.labels.pop();\n    return this.finishNode(node, \"SwitchStatement\");\n  }\n\n  parseThrowStatement(this: Parser, node: Undone<N.ThrowStatement>) {\n    this.next();\n    if (this.hasPrecedingLineBreak()) {\n      this.raise(Errors.NewlineAfterThrow, { at: this.state.lastTokEndLoc });\n    }\n    node.argument = this.parseExpression();\n    this.semicolon();\n    return this.finishNode(node, \"ThrowStatement\");\n  }\n\n  parseCatchClauseParam(this: Parser): N.Pattern {\n    const param = this.parseBindingAtom();\n\n    this.scope.enter(\n      this.options.annexB && param.type === \"Identifier\"\n        ? SCOPE_SIMPLE_CATCH\n        : 0,\n    );\n    this.checkLVal(param, {\n      in: { type: \"CatchClause\" },\n      binding: BIND_CATCH_PARAM,\n    });\n\n    return param;\n  }\n\n  parseTryStatement(\n    this: Parser,\n    node: Undone<N.TryStatement>,\n  ): N.TryStatement {\n    this.next();\n\n    node.block = this.parseBlock();\n    node.handler = null;\n\n    if (this.match(tt._catch)) {\n      const clause = this.startNode<N.CatchClause>();\n      this.next();\n      if (this.match(tt.parenL)) {\n        this.expect(tt.parenL);\n        clause.param = this.parseCatchClauseParam();\n        this.expect(tt.parenR);\n      } else {\n        clause.param = null;\n        this.scope.enter(SCOPE_OTHER);\n      }\n\n      // Parse the catch clause's body.\n      clause.body =\n        // For the smartPipelines plugin: Disable topic references from outer\n        // contexts within the catch clause's body.\n        this.withSmartMixTopicForbiddingContext(() =>\n          // Parse the catch clause's body.\n          this.parseBlock(false, false),\n        );\n\n      this.scope.exit();\n      node.handler = this.finishNode(clause, \"CatchClause\");\n    }\n\n    node.finalizer = this.eat(tt._finally) ? this.parseBlock() : null;\n\n    if (!node.handler && !node.finalizer) {\n      this.raise(Errors.NoCatchOrFinally, { at: node });\n    }\n\n    return this.finishNode(node, \"TryStatement\");\n  }\n\n  // https://tc39.es/ecma262/#prod-VariableStatement\n  // https://tc39.es/ecma262/#prod-LexicalDeclaration\n  parseVarStatement(\n    this: Parser,\n    node: Undone<N.VariableDeclaration>,\n    kind: \"var\" | \"let\" | \"const\" | \"using\" | \"await using\",\n    allowMissingInitializer: boolean = false,\n  ): N.VariableDeclaration {\n    this.next();\n    this.parseVar(node, false, kind, allowMissingInitializer);\n    this.semicolon();\n    return this.finishNode(node, \"VariableDeclaration\");\n  }\n\n  // https://tc39.es/ecma262/#prod-WhileStatement\n  parseWhileStatement(\n    this: Parser,\n    node: Undone<N.WhileStatement>,\n  ): N.WhileStatement {\n    this.next();\n    node.test = this.parseHeaderExpression();\n    this.state.labels.push(loopLabel);\n\n    // Parse the loop body.\n    node.body =\n      // For the smartPipelines plugin:\n      // Disable topic references from outer contexts within the loop body.\n      // They are permitted in test expressions, outside of the loop body.\n      this.withSmartMixTopicForbiddingContext(() =>\n        // Parse loop body.\n        this.parseStatement(),\n      );\n\n    this.state.labels.pop();\n\n    return this.finishNode(node, \"WhileStatement\");\n  }\n\n  parseWithStatement(\n    this: Parser,\n    node: Undone<N.WithStatement>,\n  ): N.WithStatement {\n    if (this.state.strict) {\n      this.raise(Errors.StrictWith, { at: this.state.startLoc });\n    }\n    this.next();\n    node.object = this.parseHeaderExpression();\n\n    // Parse the statement body.\n    node.body =\n      // For the smartPipelines plugin:\n      // Disable topic references from outer contexts within the with statement's body.\n      // They are permitted in function default-parameter expressions, which are\n      // part of the outer context, outside of the with statement's body.\n      this.withSmartMixTopicForbiddingContext(() =>\n        // Parse the statement body.\n        this.parseStatement(),\n      );\n\n    return this.finishNode(node, \"WithStatement\");\n  }\n\n  parseEmptyStatement(node: Undone<N.EmptyStatement>): N.EmptyStatement {\n    this.next();\n    return this.finishNode(node, \"EmptyStatement\");\n  }\n\n  // https://tc39.es/ecma262/#prod-LabelledStatement\n  parseLabeledStatement(\n    this: Parser,\n    node: Undone<N.LabeledStatement>,\n    maybeName: string,\n    expr: N.Identifier,\n    flags: ParseStatementFlag,\n  ): N.LabeledStatement {\n    for (const label of this.state.labels) {\n      if (label.name === maybeName) {\n        this.raise(Errors.LabelRedeclaration, {\n          at: expr,\n          labelName: maybeName,\n        });\n      }\n    }\n\n    const kind = tokenIsLoop(this.state.type)\n      ? \"loop\"\n      : this.match(tt._switch)\n      ? \"switch\"\n      : null;\n    for (let i = this.state.labels.length - 1; i >= 0; i--) {\n      const label = this.state.labels[i];\n      if (label.statementStart === node.start) {\n        label.statementStart = this.state.start;\n        label.kind = kind;\n      } else {\n        break;\n      }\n    }\n\n    this.state.labels.push({\n      name: maybeName,\n      kind: kind,\n      statementStart: this.state.start,\n    });\n    // https://tc39.es/ecma262/#prod-LabelledItem\n    node.body =\n      flags & ParseStatementFlag.AllowLabeledFunction\n        ? this.parseStatementOrSloppyAnnexBFunctionDeclaration(true)\n        : this.parseStatement();\n\n    this.state.labels.pop();\n    node.label = expr;\n    return this.finishNode(node, \"LabeledStatement\");\n  }\n\n  parseExpressionStatement(\n    node: Undone<N.ExpressionStatement>,\n    expr: N.Expression,\n    /* eslint-disable-next-line @typescript-eslint/no-unused-vars -- used in TypeScript parser */\n    decorators: N.Decorator[] | null,\n  ) {\n    node.expression = expr;\n    this.semicolon();\n    return this.finishNode(node, \"ExpressionStatement\");\n  }\n\n  // Parse a semicolon-enclosed block of statements, handling `\"use\n  // strict\"` declarations when `allowDirectives` is true (used for\n  // function bodies).\n\n  parseBlock(\n    this: Parser,\n    allowDirectives: boolean = false,\n    createNewLexicalScope: boolean = true,\n    afterBlockParse?: (hasStrictModeDirective: boolean) => void,\n  ): N.BlockStatement {\n    const node = this.startNode<N.BlockStatement>();\n    if (allowDirectives) {\n      this.state.strictErrors.clear();\n    }\n    this.expect(tt.braceL);\n    if (createNewLexicalScope) {\n      this.scope.enter(SCOPE_OTHER);\n    }\n    this.parseBlockBody(\n      node,\n      allowDirectives,\n      false,\n      tt.braceR,\n      afterBlockParse,\n    );\n    if (createNewLexicalScope) {\n      this.scope.exit();\n    }\n    return this.finishNode(node, \"BlockStatement\");\n  }\n\n  isValidDirective(stmt: N.Statement): boolean {\n    return (\n      stmt.type === \"ExpressionStatement\" &&\n      stmt.expression.type === \"StringLiteral\" &&\n      !stmt.expression.extra.parenthesized\n    );\n  }\n\n  parseBlockBody(\n    this: Parser,\n    node: Undone<N.BlockStatementLike>,\n    allowDirectives: boolean | undefined | null,\n    topLevel: boolean,\n    end: TokenType,\n    afterBlockParse?: (hasStrictModeDirective: boolean) => void,\n  ): void {\n    const body: N.BlockStatementLike[\"body\"] = (node.body = []);\n    const directives: N.BlockStatementLike[\"directives\"] = (node.directives =\n      []);\n    this.parseBlockOrModuleBlockBody(\n      body,\n      allowDirectives ? directives : undefined,\n      topLevel,\n      end,\n      afterBlockParse,\n    );\n  }\n\n  // Undefined directives means that directives are not allowed.\n  // https://tc39.es/ecma262/#prod-Block\n  // https://tc39.es/ecma262/#prod-ModuleBody\n  parseBlockOrModuleBlockBody(\n    this: Parser,\n    body: N.Statement[],\n    directives: N.Directive[] | undefined | null,\n    topLevel: boolean,\n    end: TokenType,\n    afterBlockParse?: (hasStrictModeDirective: boolean) => void,\n  ): void {\n    const oldStrict = this.state.strict;\n    let hasStrictModeDirective = false;\n    let parsedNonDirective = false;\n\n    while (!this.match(end)) {\n      const stmt = topLevel\n        ? this.parseModuleItem()\n        : this.parseStatementListItem();\n\n      if (directives && !parsedNonDirective) {\n        if (this.isValidDirective(stmt)) {\n          const directive = this.stmtToDirective(stmt);\n          directives.push(directive);\n\n          if (\n            !hasStrictModeDirective &&\n            directive.value.value === \"use strict\"\n          ) {\n            hasStrictModeDirective = true;\n            this.setStrict(true);\n          }\n\n          continue;\n        }\n        parsedNonDirective = true;\n        // clear strict errors since the strict mode will not change within the block\n        this.state.strictErrors.clear();\n      }\n      body.push(stmt);\n    }\n\n    if (afterBlockParse) {\n      afterBlockParse.call(this, hasStrictModeDirective);\n    }\n\n    if (!oldStrict) {\n      this.setStrict(false);\n    }\n\n    this.next();\n  }\n\n  // Parse a regular `for` loop. The disambiguation code in\n  // `parseStatement` will already have parsed the init statement or\n  // expression.\n\n  parseFor(\n    this: Parser,\n    node: Undone<N.ForStatement>,\n    init?: N.VariableDeclaration | N.Expression | null,\n  ): N.ForStatement {\n    node.init = init;\n    this.semicolon(/* allowAsi */ false);\n    node.test = this.match(tt.semi) ? null : this.parseExpression();\n    this.semicolon(/* allowAsi */ false);\n    node.update = this.match(tt.parenR) ? null : this.parseExpression();\n    this.expect(tt.parenR);\n\n    // Parse the loop body.\n    node.body =\n      // For the smartPipelines plugin: Disable topic references from outer\n      // contexts within the loop body. They are permitted in test expressions,\n      // outside of the loop body.\n      this.withSmartMixTopicForbiddingContext(() =>\n        // Parse the loop body.\n        this.parseStatement(),\n      );\n\n    this.scope.exit();\n    this.state.labels.pop();\n\n    return this.finishNode(node, \"ForStatement\");\n  }\n\n  // Parse a `for`/`in` and `for`/`of` loop, which are almost\n  // same from parser's perspective.\n\n  parseForIn(\n    this: Parser,\n    node: Undone<N.ForInOf>,\n    init: N.VariableDeclaration | N.AssignmentPattern,\n    awaitAt?: Position | null,\n  ): N.ForInOf {\n    const isForIn = this.match(tt._in);\n    this.next();\n\n    if (isForIn) {\n      if (awaitAt !== null) this.unexpected(awaitAt);\n    } else {\n      node.await = awaitAt !== null;\n    }\n\n    if (\n      init.type === \"VariableDeclaration\" &&\n      init.declarations[0].init != null &&\n      (!isForIn ||\n        !this.options.annexB ||\n        this.state.strict ||\n        init.kind !== \"var\" ||\n        init.declarations[0].id.type !== \"Identifier\")\n    ) {\n      this.raise(Errors.ForInOfLoopInitializer, {\n        at: init,\n        type: isForIn ? \"ForInStatement\" : \"ForOfStatement\",\n      });\n    }\n\n    if (init.type === \"AssignmentPattern\") {\n      this.raise(Errors.InvalidLhs, {\n        at: init,\n        ancestor: { type: \"ForStatement\" },\n      });\n    }\n\n    node.left = init;\n    node.right = isForIn\n      ? this.parseExpression()\n      : this.parseMaybeAssignAllowIn();\n    this.expect(tt.parenR);\n\n    // Parse the loop body.\n    node.body =\n      // For the smartPipelines plugin:\n      // Disable topic references from outer contexts within the loop body.\n      // They are permitted in test expressions, outside of the loop body.\n      this.withSmartMixTopicForbiddingContext(() =>\n        // Parse loop body.\n        this.parseStatement(),\n      );\n\n    this.scope.exit();\n    this.state.labels.pop();\n\n    return this.finishNode(node, isForIn ? \"ForInStatement\" : \"ForOfStatement\");\n  }\n\n  // Parse a list of variable declarations.\n\n  parseVar(\n    this: Parser,\n    node: Undone<N.VariableDeclaration>,\n    isFor: boolean,\n    kind: \"var\" | \"let\" | \"const\" | \"using\" | \"await using\",\n    allowMissingInitializer: boolean = false,\n  ): Undone<N.VariableDeclaration> {\n    const declarations: N.VariableDeclarator[] = (node.declarations = []);\n    node.kind = kind;\n    for (;;) {\n      const decl = this.startNode<N.VariableDeclarator>();\n      this.parseVarId(decl, kind);\n      decl.init = !this.eat(tt.eq)\n        ? null\n        : isFor\n        ? this.parseMaybeAssignDisallowIn()\n        : this.parseMaybeAssignAllowIn();\n\n      if (decl.init === null && !allowMissingInitializer) {\n        if (\n          decl.id.type !== \"Identifier\" &&\n          !(isFor && (this.match(tt._in) || this.isContextual(tt._of)))\n        ) {\n          this.raise(Errors.DeclarationMissingInitializer, {\n            at: this.state.lastTokEndLoc,\n            kind: \"destructuring\",\n          });\n        } else if (\n          kind === \"const\" &&\n          !(this.match(tt._in) || this.isContextual(tt._of))\n        ) {\n          this.raise(Errors.DeclarationMissingInitializer, {\n            at: this.state.lastTokEndLoc,\n            kind: \"const\",\n          });\n        }\n      }\n      declarations.push(this.finishNode(decl, \"VariableDeclarator\"));\n      if (!this.eat(tt.comma)) break;\n    }\n    return node;\n  }\n\n  parseVarId(\n    this: Parser,\n    decl: Undone<N.VariableDeclarator>,\n    kind: \"var\" | \"let\" | \"const\" | \"using\" | \"await using\",\n  ): void {\n    const id = this.parseBindingAtom();\n    this.checkLVal(id, {\n      in: { type: \"VariableDeclarator\" },\n      binding: kind === \"var\" ? BIND_VAR : BIND_LEXICAL,\n    });\n    decl.id = id;\n  }\n\n  // https://tc39.es/ecma262/#prod-AsyncFunctionExpression\n  parseAsyncFunctionExpression(\n    this: Parser,\n    node: Undone<N.FunctionExpression>,\n  ): N.FunctionExpression {\n    return this.parseFunction(node, ParseFunctionFlag.Async);\n  }\n\n  // Parse a function declaration or expression (depending on the\n  // ParseFunctionFlag.Declaration flag).\n\n  parseFunction<T extends N.NormalFunction>(\n    this: Parser,\n    node: Undone<T>,\n    flags: ParseFunctionFlag = ParseFunctionFlag.Expression,\n  ): T {\n    const hangingDeclaration = flags & ParseFunctionFlag.HangingDeclaration;\n    const isDeclaration = !!(flags & ParseFunctionFlag.Declaration);\n    const requireId = isDeclaration && !(flags & ParseFunctionFlag.NullableId);\n    const isAsync = !!(flags & ParseFunctionFlag.Async);\n\n    this.initFunction(node, isAsync);\n\n    if (this.match(tt.star)) {\n      if (hangingDeclaration) {\n        this.raise(Errors.GeneratorInSingleStatementContext, {\n          at: this.state.startLoc,\n        });\n      }\n      this.next(); // eat *\n      node.generator = true;\n    }\n\n    if (isDeclaration) {\n      node.id = this.parseFunctionId(requireId);\n    }\n\n    const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;\n    this.state.maybeInArrowParameters = false;\n    this.scope.enter(SCOPE_FUNCTION);\n    this.prodParam.enter(functionFlags(isAsync, node.generator));\n\n    if (!isDeclaration) {\n      node.id = this.parseFunctionId();\n    }\n\n    this.parseFunctionParams(node, /* isConstructor */ false);\n\n    // For the smartPipelines plugin: Disable topic references from outer\n    // contexts within the function body. They are permitted in function\n    // default-parameter expressions, outside of the function body.\n    this.withSmartMixTopicForbiddingContext(() => {\n      // Parse the function body.\n      this.parseFunctionBodyAndFinish(\n        node,\n        isDeclaration ? \"FunctionDeclaration\" : \"FunctionExpression\",\n      );\n    });\n\n    this.prodParam.exit();\n    this.scope.exit();\n\n    if (isDeclaration && !hangingDeclaration) {\n      // We need to register this _after_ parsing the function body\n      // because of TypeScript body-less function declarations,\n      // which shouldn't be added to the scope.\n      this.registerFunctionStatementId(node as T);\n    }\n\n    this.state.maybeInArrowParameters = oldMaybeInArrowParameters;\n    return node as T;\n  }\n\n  parseFunctionId(requireId?: boolean): N.Identifier | undefined | null {\n    return requireId || tokenIsIdentifier(this.state.type)\n      ? this.parseIdentifier()\n      : null;\n  }\n\n  parseFunctionParams(\n    this: Parser,\n    node: Undone<N.Function>,\n    isConstructor?: boolean,\n  ): void {\n    this.expect(tt.parenL);\n    this.expressionScope.enter(newParameterDeclarationScope());\n    node.params = this.parseBindingList(\n      tt.parenR,\n      charCodes.rightParenthesis,\n      ParseBindingListFlags.IS_FUNCTION_PARAMS |\n        (isConstructor ? ParseBindingListFlags.IS_CONSTRUCTOR_PARAMS : 0),\n    );\n\n    this.expressionScope.exit();\n  }\n\n  registerFunctionStatementId(node: N.Function): void {\n    if (!node.id) return;\n\n    // If it is a regular function declaration in sloppy mode, then it is\n    // subject to Annex B semantics (BIND_FUNCTION). Otherwise, the binding\n    // mode depends on properties of the current scope (see\n    // treatFunctionsAsVar).\n    this.scope.declareName(\n      node.id.name,\n      !this.options.annexB || this.state.strict || node.generator || node.async\n        ? this.scope.treatFunctionsAsVar\n          ? BIND_VAR\n          : BIND_LEXICAL\n        : BIND_FUNCTION,\n      node.id.loc.start,\n    );\n  }\n\n  // Parse a class declaration or literal (depending on the\n  // `isStatement` parameter).\n\n  parseClass<T extends N.Class>(\n    this: Parser,\n    node: Undone<T>,\n    isStatement: /* T === ClassDeclaration */ boolean,\n    optionalId?: boolean,\n  ): T {\n    this.next(); // 'class'\n\n    // A class definition is always strict mode code.\n    const oldStrict = this.state.strict;\n    this.state.strict = true;\n\n    this.parseClassId(node, isStatement, optionalId);\n    this.parseClassSuper(node);\n    // this.state.strict is restored in parseClassBody\n    node.body = this.parseClassBody(!!node.superClass, oldStrict);\n\n    return this.finishNode(\n      node,\n      isStatement ? \"ClassDeclaration\" : \"ClassExpression\",\n    );\n  }\n\n  isClassProperty(): boolean {\n    return this.match(tt.eq) || this.match(tt.semi) || this.match(tt.braceR);\n  }\n\n  isClassMethod(): boolean {\n    return this.match(tt.parenL);\n  }\n\n  isNonstaticConstructor(method: N.ClassMethod | N.ClassProperty): boolean {\n    return (\n      !method.computed &&\n      !method.static &&\n      (method.key.name === \"constructor\" || // Identifier\n        method.key.value === \"constructor\") // String literal\n    );\n  }\n\n  // https://tc39.es/ecma262/#prod-ClassBody\n  parseClassBody(\n    this: Parser,\n    hadSuperClass: boolean,\n    oldStrict: boolean,\n  ): N.ClassBody {\n    this.classScope.enter();\n\n    const state: N.ParseClassMemberState = {\n      hadConstructor: false,\n      hadSuperClass,\n    };\n    let decorators: N.Decorator[] = [];\n    const classBody = this.startNode<N.ClassBody>();\n    classBody.body = [];\n\n    this.expect(tt.braceL);\n\n    // For the smartPipelines plugin: Disable topic references from outer\n    // contexts within the class body.\n    this.withSmartMixTopicForbiddingContext(() => {\n      // Parse the contents within the braces.\n      while (!this.match(tt.braceR)) {\n        if (this.eat(tt.semi)) {\n          if (decorators.length > 0) {\n            throw this.raise(Errors.DecoratorSemicolon, {\n              at: this.state.lastTokEndLoc,\n            });\n          }\n          continue;\n        }\n\n        if (this.match(tt.at)) {\n          decorators.push(this.parseDecorator());\n          continue;\n        }\n\n        const member = this.startNode<N.ClassMember>();\n\n        // steal the decorators if there are any\n        if (decorators.length) {\n          // @ts-expect-error Fixme\n          member.decorators = decorators;\n          this.resetStartLocationFromNode(member, decorators[0]);\n          decorators = [];\n        }\n\n        this.parseClassMember(classBody, member, state);\n\n        if (\n          // @ts-expect-error Fixme\n          member.kind === \"constructor\" &&\n          // @ts-expect-error Fixme\n          member.decorators &&\n          // @ts-expect-error Fixme\n          member.decorators.length > 0\n        ) {\n          this.raise(Errors.DecoratorConstructor, { at: member });\n        }\n      }\n    });\n\n    this.state.strict = oldStrict;\n\n    this.next(); // eat `}`\n\n    if (decorators.length) {\n      throw this.raise(Errors.TrailingDecorator, { at: this.state.startLoc });\n    }\n\n    this.classScope.exit();\n\n    return this.finishNode(classBody, \"ClassBody\");\n  }\n\n  // returns true if the current identifier is a method/field name,\n  // false if it is a modifier\n  parseClassMemberFromModifier(\n    this: Parser,\n    classBody: Undone<N.ClassBody>,\n    member: Undone<N.ClassMember>,\n  ): boolean {\n    const key = this.parseIdentifier(true); // eats the modifier\n\n    if (this.isClassMethod()) {\n      const method: N.ClassMethod = member as any;\n\n      // a method named like the modifier\n      method.kind = \"method\";\n      method.computed = false;\n      method.key = key;\n      method.static = false;\n      this.pushClassMethod(\n        classBody,\n        method,\n        false,\n        false,\n        /* isConstructor */ false,\n        false,\n      );\n      return true;\n    } else if (this.isClassProperty()) {\n      const prop: N.ClassProperty = member as any;\n\n      // a property named like the modifier\n      prop.computed = false;\n      prop.key = key;\n      prop.static = false;\n      classBody.body.push(this.parseClassProperty(prop));\n      return true;\n    }\n    this.resetPreviousNodeTrailingComments(key);\n    return false;\n  }\n\n  parseClassMember(\n    this: Parser,\n    classBody: Undone<N.ClassBody>,\n    member: Undone<N.ClassMember>,\n    state: N.ParseClassMemberState,\n  ): void {\n    const isStatic = this.isContextual(tt._static);\n\n    if (isStatic) {\n      if (this.parseClassMemberFromModifier(classBody, member)) {\n        // a class element named 'static'\n        return;\n      }\n      if (this.eat(tt.braceL)) {\n        this.parseClassStaticBlock(classBody, member as any as N.StaticBlock);\n        return;\n      }\n    }\n\n    this.parseClassMemberWithIsStatic(classBody, member, state, isStatic);\n  }\n\n  parseClassMemberWithIsStatic(\n    this: Parser,\n    classBody: Undone<N.ClassBody>,\n    member: Undone<N.ClassMember>,\n    state: N.ParseClassMemberState,\n    isStatic: boolean,\n  ) {\n    const publicMethod = member as N.ClassMethod;\n    const privateMethod = member as N.ClassPrivateMethod;\n    const publicProp = member as N.ClassProperty;\n    const privateProp = member as N.ClassPrivateProperty;\n    const accessorProp = member as N.ClassAccessorProperty;\n\n    const method: typeof publicMethod | typeof privateMethod = publicMethod;\n    const publicMember: typeof publicMethod | typeof publicProp = publicMethod;\n\n    member.static = isStatic;\n    this.parsePropertyNamePrefixOperator(member);\n\n    if (this.eat(tt.star)) {\n      // a generator\n      method.kind = \"method\";\n      const isPrivateName = this.match(tt.privateName);\n      this.parseClassElementName(method);\n\n      if (isPrivateName) {\n        // Private generator method\n        this.pushClassPrivateMethod(classBody, privateMethod, true, false);\n        return;\n      }\n\n      if (this.isNonstaticConstructor(publicMethod)) {\n        this.raise(Errors.ConstructorIsGenerator, {\n          at: publicMethod.key,\n        });\n      }\n\n      this.pushClassMethod(\n        classBody,\n        publicMethod,\n        true,\n        false,\n        /* isConstructor */ false,\n        false,\n      );\n\n      return;\n    }\n\n    const isContextual =\n      tokenIsIdentifier(this.state.type) && !this.state.containsEsc;\n    const isPrivate = this.match(tt.privateName);\n    const key = this.parseClassElementName(member);\n    const maybeQuestionTokenStartLoc = this.state.startLoc;\n\n    this.parsePostMemberNameModifiers(publicMember);\n\n    if (this.isClassMethod()) {\n      method.kind = \"method\";\n\n      if (isPrivate) {\n        this.pushClassPrivateMethod(classBody, privateMethod, false, false);\n        return;\n      }\n\n      // a normal method\n      const isConstructor = this.isNonstaticConstructor(publicMethod);\n      let allowsDirectSuper = false;\n      if (isConstructor) {\n        publicMethod.kind = \"constructor\";\n\n        // TypeScript allows multiple overloaded constructor declarations.\n        if (state.hadConstructor && !this.hasPlugin(\"typescript\")) {\n          this.raise(Errors.DuplicateConstructor, { at: key });\n        }\n        if (isConstructor && this.hasPlugin(\"typescript\") && member.override) {\n          this.raise(Errors.OverrideOnConstructor, { at: key });\n        }\n        state.hadConstructor = true;\n        allowsDirectSuper = state.hadSuperClass;\n      }\n\n      this.pushClassMethod(\n        classBody,\n        publicMethod,\n        false,\n        false,\n        isConstructor,\n        allowsDirectSuper,\n      );\n    } else if (this.isClassProperty()) {\n      if (isPrivate) {\n        this.pushClassPrivateProperty(classBody, privateProp);\n      } else {\n        this.pushClassProperty(classBody, publicProp);\n      }\n    } else if (\n      isContextual &&\n      key.name === \"async\" &&\n      !this.isLineTerminator()\n    ) {\n      // an async method\n      this.resetPreviousNodeTrailingComments(key);\n      const isGenerator = this.eat(tt.star);\n\n      if (publicMember.optional) {\n        this.unexpected(maybeQuestionTokenStartLoc);\n      }\n\n      method.kind = \"method\";\n      // The so-called parsed name would have been \"async\": get the real name.\n      const isPrivate = this.match(tt.privateName);\n      this.parseClassElementName(method);\n      this.parsePostMemberNameModifiers(publicMember);\n\n      if (isPrivate) {\n        // private async method\n        this.pushClassPrivateMethod(\n          classBody,\n          privateMethod,\n          isGenerator,\n          true,\n        );\n      } else {\n        if (this.isNonstaticConstructor(publicMethod)) {\n          this.raise(Errors.ConstructorIsAsync, { at: publicMethod.key });\n        }\n\n        this.pushClassMethod(\n          classBody,\n          publicMethod,\n          isGenerator,\n          true,\n          /* isConstructor */ false,\n          false,\n        );\n      }\n    } else if (\n      isContextual &&\n      (key.name === \"get\" || key.name === \"set\") &&\n      !(this.match(tt.star) && this.isLineTerminator())\n    ) {\n      // `get\\n*` is an uninitialized property named 'get' followed by a generator.\n      // a getter or setter\n      this.resetPreviousNodeTrailingComments(key);\n      method.kind = key.name;\n      // The so-called parsed name would have been \"get/set\": get the real name.\n      const isPrivate = this.match(tt.privateName);\n      this.parseClassElementName(publicMethod);\n\n      if (isPrivate) {\n        // private getter/setter\n        this.pushClassPrivateMethod(classBody, privateMethod, false, false);\n      } else {\n        if (this.isNonstaticConstructor(publicMethod)) {\n          this.raise(Errors.ConstructorIsAccessor, { at: publicMethod.key });\n        }\n        this.pushClassMethod(\n          classBody,\n          publicMethod,\n          false,\n          false,\n          /* isConstructor */ false,\n          false,\n        );\n      }\n\n      this.checkGetterSetterParams(publicMethod);\n    } else if (\n      isContextual &&\n      key.name === \"accessor\" &&\n      !this.isLineTerminator()\n    ) {\n      this.expectPlugin(\"decoratorAutoAccessors\");\n      this.resetPreviousNodeTrailingComments(key);\n\n      // The so-called parsed name would have been \"accessor\": get the real name.\n      const isPrivate = this.match(tt.privateName);\n      this.parseClassElementName(publicProp);\n      this.pushClassAccessorProperty(classBody, accessorProp, isPrivate);\n    } else if (this.isLineTerminator()) {\n      // an uninitialized class property (due to ASI, since we don't otherwise recognize the next token)\n      if (isPrivate) {\n        this.pushClassPrivateProperty(classBody, privateProp);\n      } else {\n        this.pushClassProperty(classBody, publicProp);\n      }\n    } else {\n      this.unexpected();\n    }\n  }\n\n  // https://tc39.es/ecma262/#prod-ClassElementName\n  parseClassElementName(\n    this: Parser,\n    member: Undone<N.ClassMember>,\n  ): N.Expression | N.Identifier {\n    const { type, value } = this.state;\n    if (\n      (type === tt.name || type === tt.string) &&\n      member.static &&\n      value === \"prototype\"\n    ) {\n      this.raise(Errors.StaticPrototype, { at: this.state.startLoc });\n    }\n\n    if (type === tt.privateName) {\n      if (value === \"constructor\") {\n        this.raise(Errors.ConstructorClassPrivateField, {\n          at: this.state.startLoc,\n        });\n      }\n      const key = this.parsePrivateName();\n      member.key = key;\n      return key;\n    }\n\n    return this.parsePropertyName(member);\n  }\n\n  parseClassStaticBlock(\n    this: Parser,\n    classBody: Undone<N.ClassBody>,\n    member: Undone<\n      N.StaticBlock & {\n        decorators?: Array<N.Decorator>;\n      }\n    >,\n  ) {\n    // Start a new lexical scope\n    this.scope.enter(SCOPE_CLASS | SCOPE_STATIC_BLOCK | SCOPE_SUPER);\n    // Start a new scope with regard to loop labels\n    const oldLabels = this.state.labels;\n    this.state.labels = [];\n    // ClassStaticBlockStatementList:\n    //   StatementList[~Yield, ~Await, ~Return] opt\n    this.prodParam.enter(PARAM);\n    const body: N.Node[] = (member.body = []);\n    this.parseBlockOrModuleBlockBody(body, undefined, false, tt.braceR);\n    this.prodParam.exit();\n    this.scope.exit();\n    this.state.labels = oldLabels;\n    classBody.body.push(this.finishNode<N.StaticBlock>(member, \"StaticBlock\"));\n    if (member.decorators?.length) {\n      this.raise(Errors.DecoratorStaticBlock, { at: member });\n    }\n  }\n\n  pushClassProperty(\n    this: Parser,\n    classBody: Undone<N.ClassBody>,\n    prop: N.ClassProperty,\n  ) {\n    if (\n      !prop.computed &&\n      (prop.key.name === \"constructor\" || prop.key.value === \"constructor\")\n    ) {\n      // Non-computed field, which is either an identifier named \"constructor\"\n      // or a string literal named \"constructor\"\n      this.raise(Errors.ConstructorClassField, { at: prop.key });\n    }\n\n    classBody.body.push(this.parseClassProperty(prop));\n  }\n\n  pushClassPrivateProperty(\n    this: Parser,\n    classBody: Undone<N.ClassBody>,\n    prop: Undone<N.ClassPrivateProperty>,\n  ) {\n    const node = this.parseClassPrivateProperty(prop);\n    classBody.body.push(node);\n\n    this.classScope.declarePrivateName(\n      this.getPrivateNameSV(node.key),\n      CLASS_ELEMENT_OTHER,\n      node.key.loc.start,\n    );\n  }\n\n  pushClassAccessorProperty(\n    this: Parser,\n    classBody: Undone<N.ClassBody>,\n    prop: N.ClassAccessorProperty,\n    isPrivate: boolean,\n  ) {\n    if (!isPrivate && !prop.computed) {\n      // Not private, so not node is not a PrivateName and we can safely cast\n      const key = prop.key as N.Expression;\n\n      if (key.name === \"constructor\" || key.value === \"constructor\") {\n        // Non-computed field, which is either an identifier named \"constructor\"\n        // or a string literal named \"constructor\"\n        this.raise(Errors.ConstructorClassField, { at: key });\n      }\n    }\n\n    const node = this.parseClassAccessorProperty(prop);\n    classBody.body.push(node);\n\n    if (isPrivate) {\n      this.classScope.declarePrivateName(\n        this.getPrivateNameSV(node.key),\n        CLASS_ELEMENT_OTHER,\n        node.key.loc.start,\n      );\n    }\n  }\n\n  pushClassMethod(\n    this: Parser,\n    classBody: Undone<N.ClassBody>,\n    method: Undone<N.ClassMethod>,\n    isGenerator: boolean,\n    isAsync: boolean,\n    isConstructor: boolean,\n    allowsDirectSuper: boolean,\n  ): void {\n    classBody.body.push(\n      this.parseMethod(\n        method,\n        isGenerator,\n        isAsync,\n        isConstructor,\n        allowsDirectSuper,\n        \"ClassMethod\",\n        true,\n      ),\n    );\n  }\n\n  pushClassPrivateMethod(\n    this: Parser,\n    classBody: Undone<N.ClassBody>,\n    method: Undone<N.ClassPrivateMethod>,\n    isGenerator: boolean,\n    isAsync: boolean,\n  ): void {\n    const node = this.parseMethod(\n      method,\n      isGenerator,\n      isAsync,\n      /* isConstructor */ false,\n      false,\n      \"ClassPrivateMethod\",\n      true,\n    );\n    classBody.body.push(node);\n\n    const kind =\n      node.kind === \"get\"\n        ? node.static\n          ? CLASS_ELEMENT_STATIC_GETTER\n          : CLASS_ELEMENT_INSTANCE_GETTER\n        : node.kind === \"set\"\n        ? node.static\n          ? CLASS_ELEMENT_STATIC_SETTER\n          : CLASS_ELEMENT_INSTANCE_SETTER\n        : CLASS_ELEMENT_OTHER;\n    this.declareClassPrivateMethodInScope(node, kind);\n  }\n\n  declareClassPrivateMethodInScope(\n    node: Undone<\n      N.ClassPrivateMethod | N.EstreeMethodDefinition | N.TSDeclareMethod\n    >,\n    kind: number,\n  ) {\n    this.classScope.declarePrivateName(\n      this.getPrivateNameSV(node.key),\n      kind,\n      node.key.loc.start,\n    );\n  }\n\n  // Overridden in typescript.js\n  parsePostMemberNameModifiers(\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    methodOrProp: Undone<N.ClassMethod | N.ClassProperty>,\n  ): void {}\n\n  // https://tc39.es/ecma262/#prod-FieldDefinition\n  parseClassPrivateProperty(\n    this: Parser,\n    node: Undone<N.ClassPrivateProperty>,\n  ): N.ClassPrivateProperty {\n    this.parseInitializer(node);\n    this.semicolon();\n    return this.finishNode(node, \"ClassPrivateProperty\");\n  }\n\n  // https://tc39.es/ecma262/#prod-FieldDefinition\n  parseClassProperty(this: Parser, node: N.ClassProperty): N.ClassProperty {\n    this.parseInitializer(node);\n    this.semicolon();\n    return this.finishNode(node, \"ClassProperty\");\n  }\n\n  parseClassAccessorProperty(\n    this: Parser,\n    node: N.ClassAccessorProperty,\n  ): N.ClassAccessorProperty {\n    this.parseInitializer(node);\n    this.semicolon();\n    return this.finishNode(node, \"ClassAccessorProperty\");\n  }\n\n  // https://tc39.es/ecma262/#prod-Initializer\n  parseInitializer(\n    this: Parser,\n    node: Undone<\n      N.ClassProperty | N.ClassPrivateProperty | N.ClassAccessorProperty\n    >,\n  ): void {\n    this.scope.enter(SCOPE_CLASS | SCOPE_SUPER);\n    this.expressionScope.enter(newExpressionScope());\n    this.prodParam.enter(PARAM);\n    node.value = this.eat(tt.eq) ? this.parseMaybeAssignAllowIn() : null;\n    this.expressionScope.exit();\n    this.prodParam.exit();\n    this.scope.exit();\n  }\n\n  parseClassId(\n    node: Undone<N.Class>,\n    isStatement: boolean,\n    optionalId?: boolean | null,\n    bindingType: BindingTypes = BIND_CLASS,\n  ): void {\n    if (tokenIsIdentifier(this.state.type)) {\n      node.id = this.parseIdentifier();\n      if (isStatement) {\n        this.declareNameFromIdentifier(node.id, bindingType);\n      }\n    } else {\n      if (optionalId || !isStatement) {\n        node.id = null;\n      } else {\n        throw this.raise(Errors.MissingClassName, { at: this.state.startLoc });\n      }\n    }\n  }\n\n  // https://tc39.es/ecma262/#prod-ClassHeritage\n  parseClassSuper(this: Parser, node: Undone<N.Class>): void {\n    node.superClass = this.eat(tt._extends) ? this.parseExprSubscripts() : null;\n  }\n\n  // Parses module export declaration.\n  // https://tc39.es/ecma262/#prod-ExportDeclaration\n\n  parseExport(\n    this: Parser,\n    node: Undone<\n      | N.ExportDefaultDeclaration\n      | N.ExportAllDeclaration\n      | N.ExportNamedDeclaration\n    >,\n    decorators: N.Decorator[] | null,\n  ): N.AnyExport {\n    const maybeDefaultIdentifier = this.parseMaybeImportPhase(\n      node,\n      /* isExport */ true,\n    );\n    const hasDefault = this.maybeParseExportDefaultSpecifier(\n      node,\n      maybeDefaultIdentifier,\n    );\n    const parseAfterDefault = !hasDefault || this.eat(tt.comma);\n    const hasStar =\n      parseAfterDefault &&\n      this.eatExportStar(\n        // @ts-expect-error todo(flow->ts)\n        node,\n      );\n    const hasNamespace =\n      hasStar &&\n      this.maybeParseExportNamespaceSpecifier(\n        // @ts-expect-error todo(flow->ts)\n        node,\n      );\n    const parseAfterNamespace =\n      parseAfterDefault && (!hasNamespace || this.eat(tt.comma));\n    const isFromRequired = hasDefault || hasStar;\n\n    if (hasStar && !hasNamespace) {\n      if (hasDefault) this.unexpected();\n      if (decorators) {\n        throw this.raise(Errors.UnsupportedDecoratorExport, { at: node });\n      }\n      this.parseExportFrom(node as Undone<N.ExportNamedDeclaration>, true);\n\n      return this.finishNode(node, \"ExportAllDeclaration\");\n    }\n\n    const hasSpecifiers = this.maybeParseExportNamedSpecifiers(\n      // @ts-expect-error todo(flow->ts)\n      node,\n    );\n\n    if (hasDefault && parseAfterDefault && !hasStar && !hasSpecifiers) {\n      this.unexpected(null, tt.braceL);\n    }\n\n    if (hasNamespace && parseAfterNamespace) {\n      this.unexpected(null, tt._from);\n    }\n\n    let hasDeclaration;\n    if (isFromRequired || hasSpecifiers) {\n      hasDeclaration = false;\n      if (decorators) {\n        throw this.raise(Errors.UnsupportedDecoratorExport, { at: node });\n      }\n      this.parseExportFrom(\n        node as Undone<N.ExportNamedDeclaration>,\n        isFromRequired,\n      );\n    } else {\n      hasDeclaration = this.maybeParseExportDeclaration(\n        node as Undone<N.ExportNamedDeclaration>,\n      );\n    }\n\n    if (isFromRequired || hasSpecifiers || hasDeclaration) {\n      const node2 = node as Undone<N.ExportNamedDeclaration>;\n      this.checkExport(node2, true, false, !!node2.source);\n      if (node2.declaration?.type === \"ClassDeclaration\") {\n        this.maybeTakeDecorators(decorators, node2.declaration, node2);\n      } else if (decorators) {\n        throw this.raise(Errors.UnsupportedDecoratorExport, { at: node });\n      }\n      return this.finishNode(node2, \"ExportNamedDeclaration\");\n    }\n\n    if (this.eat(tt._default)) {\n      const node2 = node as Undone<N.ExportDefaultDeclaration>;\n      // export default ...\n      const decl = this.parseExportDefaultExpression();\n      node2.declaration = decl;\n\n      if (decl.type === \"ClassDeclaration\") {\n        this.maybeTakeDecorators(decorators, decl as N.ClassDeclaration, node2);\n      } else if (decorators) {\n        throw this.raise(Errors.UnsupportedDecoratorExport, { at: node });\n      }\n\n      this.checkExport(node2, true, true);\n\n      return this.finishNode(node2, \"ExportDefaultDeclaration\");\n    }\n\n    this.unexpected(null, tt.braceL);\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  eatExportStar(node: N.Node): boolean {\n    return this.eat(tt.star);\n  }\n\n  maybeParseExportDefaultSpecifier(\n    node: Undone<\n      | N.ExportDefaultDeclaration\n      | N.ExportAllDeclaration\n      | N.ExportNamedDeclaration\n    >,\n    maybeDefaultIdentifier: N.Identifier | null,\n  ): node is Undone<N.ExportNamedDeclaration> {\n    if (maybeDefaultIdentifier || this.isExportDefaultSpecifier()) {\n      // export defaultObj ...\n      this.expectPlugin(\"exportDefaultFrom\", maybeDefaultIdentifier?.loc.start);\n      const id = maybeDefaultIdentifier || this.parseIdentifier(true);\n      const specifier = this.startNodeAtNode<N.ExportDefaultSpecifier>(id);\n      specifier.exported = id;\n      (node as Undone<N.ExportNamedDeclaration>).specifiers = [\n        this.finishNode(specifier, \"ExportDefaultSpecifier\"),\n      ];\n      return true;\n    }\n    return false;\n  }\n\n  maybeParseExportNamespaceSpecifier(node: N.Node): boolean {\n    if (this.isContextual(tt._as)) {\n      if (!node.specifiers) node.specifiers = [];\n\n      const specifier = this.startNodeAt(this.state.lastTokStartLoc);\n\n      this.next();\n\n      specifier.exported = this.parseModuleExportName();\n      node.specifiers.push(\n        this.finishNode(specifier, \"ExportNamespaceSpecifier\"),\n      );\n      return true;\n    }\n    return false;\n  }\n\n  maybeParseExportNamedSpecifiers(node: N.Node): boolean {\n    if (this.match(tt.braceL)) {\n      if (!node.specifiers) node.specifiers = [];\n      const isTypeExport = node.exportKind === \"type\";\n      node.specifiers.push(...this.parseExportSpecifiers(isTypeExport));\n\n      node.source = null;\n      node.declaration = null;\n      if (this.hasPlugin(\"importAssertions\")) {\n        node.assertions = [];\n      }\n\n      return true;\n    }\n    return false;\n  }\n\n  maybeParseExportDeclaration(\n    this: Parser,\n    node: Undone<N.ExportNamedDeclaration>,\n  ): boolean {\n    if (this.shouldParseExportDeclaration()) {\n      node.specifiers = [];\n      node.source = null;\n      if (this.hasPlugin(\"importAssertions\")) {\n        node.assertions = [];\n      }\n      node.declaration = this.parseExportDeclaration(node);\n      return true;\n    }\n    return false;\n  }\n\n  isAsyncFunction(): boolean {\n    if (!this.isContextual(tt._async)) return false;\n    const next = this.nextTokenInLineStart();\n    return this.isUnparsedContextual(next, \"function\");\n  }\n\n  parseExportDefaultExpression(this: Parser): N.Expression | N.Declaration {\n    const expr = this.startNode();\n\n    if (this.match(tt._function)) {\n      this.next();\n      return this.parseFunction(\n        expr as Undone<N.FunctionDeclaration>,\n        ParseFunctionFlag.Declaration | ParseFunctionFlag.NullableId,\n      );\n    } else if (this.isAsyncFunction()) {\n      this.next(); // eat 'async'\n      this.next(); // eat 'function'\n      return this.parseFunction(\n        expr as Undone<N.FunctionDeclaration>,\n        ParseFunctionFlag.Declaration |\n          ParseFunctionFlag.NullableId |\n          ParseFunctionFlag.Async,\n      );\n    }\n\n    if (this.match(tt._class)) {\n      return this.parseClass(expr as Undone<N.ClassExpression>, true, true);\n    }\n\n    if (this.match(tt.at)) {\n      if (\n        this.hasPlugin(\"decorators\") &&\n        this.getPluginOption(\"decorators\", \"decoratorsBeforeExport\") === true\n      ) {\n        this.raise(Errors.DecoratorBeforeExport, { at: this.state.startLoc });\n      }\n      return this.parseClass(\n        this.maybeTakeDecorators(\n          this.parseDecorators(false),\n          this.startNode<N.ClassDeclaration>(),\n        ),\n        true,\n        true,\n      );\n    }\n\n    if (this.match(tt._const) || this.match(tt._var) || this.isLet()) {\n      throw this.raise(Errors.UnsupportedDefaultExport, {\n        at: this.state.startLoc,\n      });\n    }\n\n    const res = this.parseMaybeAssignAllowIn();\n    this.semicolon();\n    return res;\n  }\n\n  // https://tc39.es/ecma262/#prod-ExportDeclaration\n  parseExportDeclaration(\n    this: Parser,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    node: Undone<N.ExportNamedDeclaration>,\n  ): N.Declaration | undefined | null {\n    if (this.match(tt._class)) {\n      const node = this.parseClass(\n        this.startNode<N.ClassDeclaration>(),\n        true,\n        false,\n      );\n      return node;\n    }\n    return this.parseStatementListItem() as N.Declaration;\n  }\n\n  isExportDefaultSpecifier(): boolean {\n    const { type } = this.state;\n    if (tokenIsIdentifier(type)) {\n      if ((type === tt._async && !this.state.containsEsc) || type === tt._let) {\n        return false;\n      }\n      if (\n        (type === tt._type || type === tt._interface) &&\n        !this.state.containsEsc\n      ) {\n        const { type: nextType } = this.lookahead();\n        // If we see any variable name other than `from` after `type` keyword,\n        // we consider it as flow/typescript type exports\n        // note that this approach may fail on some pedantic cases\n        // export type from = number\n        if (\n          (tokenIsIdentifier(nextType) && nextType !== tt._from) ||\n          nextType === tt.braceL\n        ) {\n          this.expectOnePlugin([\"flow\", \"typescript\"]);\n          return false;\n        }\n      }\n    } else if (!this.match(tt._default)) {\n      return false;\n    }\n\n    const next = this.nextTokenStart();\n    const hasFrom = this.isUnparsedContextual(next, \"from\");\n    if (\n      this.input.charCodeAt(next) === charCodes.comma ||\n      (tokenIsIdentifier(this.state.type) && hasFrom)\n    ) {\n      return true;\n    }\n    // lookahead again when `export default from` is seen\n    if (this.match(tt._default) && hasFrom) {\n      const nextAfterFrom = this.input.charCodeAt(\n        this.nextTokenStartSince(next + 4),\n      );\n      return (\n        nextAfterFrom === charCodes.quotationMark ||\n        nextAfterFrom === charCodes.apostrophe\n      );\n    }\n    return false;\n  }\n\n  parseExportFrom(\n    this: Parser,\n    node: Undone<N.ExportNamedDeclaration>,\n    expect?: boolean,\n  ): void {\n    if (this.eatContextual(tt._from)) {\n      node.source = this.parseImportSource();\n      this.checkExport(node);\n      this.maybeParseImportAttributes(node);\n      this.checkJSONModuleImport(node);\n    } else if (expect) {\n      this.unexpected();\n    }\n\n    this.semicolon();\n  }\n\n  shouldParseExportDeclaration(): boolean {\n    const { type } = this.state;\n    if (type === tt.at) {\n      this.expectOnePlugin([\"decorators\", \"decorators-legacy\"]);\n      if (this.hasPlugin(\"decorators\")) {\n        if (\n          this.getPluginOption(\"decorators\", \"decoratorsBeforeExport\") === true\n        ) {\n          this.raise(Errors.DecoratorBeforeExport, {\n            at: this.state.startLoc,\n          });\n        }\n\n        return true;\n      }\n    }\n\n    return (\n      type === tt._var ||\n      type === tt._const ||\n      type === tt._function ||\n      type === tt._class ||\n      this.isLet() ||\n      this.isAsyncFunction()\n    );\n  }\n\n  checkExport(\n    node: Undone<N.ExportNamedDeclaration | N.ExportDefaultDeclaration>,\n    checkNames?: boolean,\n    isDefault?: boolean,\n    isFrom?: boolean,\n  ): void {\n    if (checkNames) {\n      // Check for duplicate exports\n      if (isDefault) {\n        // Default exports\n        this.checkDuplicateExports(node, \"default\");\n        if (this.hasPlugin(\"exportDefaultFrom\")) {\n          const declaration = (node as any as N.ExportDefaultDeclaration)\n            .declaration;\n          if (\n            declaration.type === \"Identifier\" &&\n            declaration.name === \"from\" &&\n            declaration.end - declaration.start === 4 && // does not contain escape\n            !declaration.extra?.parenthesized\n          ) {\n            this.raise(Errors.ExportDefaultFromAsIdentifier, {\n              at: declaration,\n            });\n          }\n        }\n        // @ts-expect-error node.specifiers may not exist\n      } else if (node.specifiers && node.specifiers.length) {\n        // Named exports\n        // @ts-expect-error node.specifiers may not exist\n        for (const specifier of node.specifiers) {\n          const { exported } = specifier;\n          const exportName =\n            exported.type === \"Identifier\" ? exported.name : exported.value;\n          this.checkDuplicateExports(specifier, exportName);\n          if (!isFrom && specifier.local) {\n            const { local } = specifier;\n            if (local.type !== \"Identifier\") {\n              this.raise(Errors.ExportBindingIsString, {\n                at: specifier,\n                localName: local.value,\n                exportName,\n              });\n            } else {\n              // check for keywords used as local names\n              this.checkReservedWord(local.name, local.loc.start, true, false);\n              // check if export is defined\n              this.scope.checkLocalExport(local);\n            }\n          }\n        }\n      } else if (node.declaration) {\n        // Exported declarations\n        if (\n          node.declaration.type === \"FunctionDeclaration\" ||\n          node.declaration.type === \"ClassDeclaration\"\n        ) {\n          const id = node.declaration.id;\n          if (!id) throw new Error(\"Assertion failure\");\n\n          this.checkDuplicateExports(node, id.name);\n        } else if (node.declaration.type === \"VariableDeclaration\") {\n          for (const declaration of node.declaration.declarations) {\n            this.checkDeclaration(declaration.id);\n          }\n        }\n      }\n    }\n  }\n\n  checkDeclaration(node: N.Pattern | N.ObjectProperty): void {\n    if (node.type === \"Identifier\") {\n      this.checkDuplicateExports(node, node.name);\n    } else if (node.type === \"ObjectPattern\") {\n      for (const prop of node.properties) {\n        this.checkDeclaration(prop);\n      }\n    } else if (node.type === \"ArrayPattern\") {\n      for (const elem of node.elements) {\n        if (elem) {\n          this.checkDeclaration(elem);\n        }\n      }\n    } else if (node.type === \"ObjectProperty\") {\n      // @ts-expect-error migrate to Babel types\n      this.checkDeclaration(node.value);\n    } else if (node.type === \"RestElement\") {\n      this.checkDeclaration(node.argument);\n    } else if (node.type === \"AssignmentPattern\") {\n      this.checkDeclaration(node.left);\n    }\n  }\n\n  checkDuplicateExports(\n    node: Undone<\n      | N.Identifier\n      | N.StringLiteral\n      | N.ExportNamedDeclaration\n      | N.ExportSpecifier\n      | N.ExportDefaultSpecifier\n    >,\n    exportName: string,\n  ): void {\n    if (this.exportedIdentifiers.has(exportName)) {\n      if (exportName === \"default\") {\n        this.raise(Errors.DuplicateDefaultExport, { at: node });\n      } else {\n        this.raise(Errors.DuplicateExport, { at: node, exportName });\n      }\n    }\n    this.exportedIdentifiers.add(exportName);\n  }\n\n  // Parses a comma-separated list of module exports.\n\n  parseExportSpecifiers(isInTypeExport: boolean): Array<N.ExportSpecifier> {\n    const nodes = [];\n    let first = true;\n\n    // export { x, y as z } [from '...']\n    this.expect(tt.braceL);\n\n    while (!this.eat(tt.braceR)) {\n      if (first) {\n        first = false;\n      } else {\n        this.expect(tt.comma);\n        if (this.eat(tt.braceR)) break;\n      }\n      const isMaybeTypeOnly = this.isContextual(tt._type);\n      const isString = this.match(tt.string);\n      const node = this.startNode();\n      node.local = this.parseModuleExportName();\n      nodes.push(\n        this.parseExportSpecifier(\n          node,\n          isString,\n          isInTypeExport,\n          isMaybeTypeOnly,\n        ),\n      );\n    }\n\n    return nodes;\n  }\n\n  parseExportSpecifier(\n    node: any,\n    isString: boolean,\n    /* eslint-disable @typescript-eslint/no-unused-vars -- used in TypeScript parser */\n    isInTypeExport: boolean,\n    isMaybeTypeOnly: boolean,\n    /* eslint-enable @typescript-eslint/no-unused-vars */\n  ): N.ExportSpecifier {\n    if (this.eatContextual(tt._as)) {\n      node.exported = this.parseModuleExportName();\n    } else if (isString) {\n      node.exported = cloneStringLiteral(node.local);\n    } else if (!node.exported) {\n      node.exported = cloneIdentifier(node.local);\n    }\n    return this.finishNode<N.ExportSpecifier>(node, \"ExportSpecifier\");\n  }\n\n  // https://tc39.es/ecma262/#prod-ModuleExportName\n  parseModuleExportName(): N.StringLiteral | N.Identifier {\n    if (this.match(tt.string)) {\n      const result = this.parseStringLiteral(this.state.value);\n      const surrogate = result.value.match(loneSurrogate);\n      if (surrogate) {\n        this.raise(Errors.ModuleExportNameHasLoneSurrogate, {\n          at: result,\n          surrogateCharCode: surrogate[0].charCodeAt(0),\n        });\n      }\n      return result;\n    }\n    return this.parseIdentifier(true);\n  }\n\n  isJSONModuleImport(\n    node: Undone<\n      N.ExportAllDeclaration | N.ExportNamedDeclaration | N.ImportDeclaration\n    >,\n  ): boolean {\n    if (node.assertions != null) {\n      return node.assertions.some(({ key, value }) => {\n        return (\n          value.value === \"json\" &&\n          (key.type === \"Identifier\"\n            ? key.name === \"type\"\n            : key.value === \"type\")\n        );\n      });\n    }\n    return false;\n  }\n\n  checkImportReflection(node: Undone<N.ImportDeclaration>) {\n    if (node.module) {\n      if (\n        node.specifiers.length !== 1 ||\n        node.specifiers[0].type !== \"ImportDefaultSpecifier\"\n      ) {\n        this.raise(Errors.ImportReflectionNotBinding, {\n          at: node.specifiers[0].loc.start,\n        });\n      }\n      if (node.assertions?.length > 0) {\n        this.raise(Errors.ImportReflectionHasAssertion, {\n          at: node.specifiers[0].loc.start,\n        });\n      }\n    }\n  }\n\n  checkJSONModuleImport(\n    node: Undone<\n      N.ExportAllDeclaration | N.ExportNamedDeclaration | N.ImportDeclaration\n    >,\n  ) {\n    // @ts-expect-error Fixme: node.type must be undefined because they are undone\n    if (this.isJSONModuleImport(node) && node.type !== \"ExportAllDeclaration\") {\n      // @ts-expect-error specifiers may not index node\n      const { specifiers } = node;\n      if (specifiers != null) {\n        // @ts-expect-error refine specifier types\n        const nonDefaultNamedSpecifier = specifiers.find(specifier => {\n          let imported;\n          if (specifier.type === \"ExportSpecifier\") {\n            imported = specifier.local;\n          } else if (specifier.type === \"ImportSpecifier\") {\n            imported = specifier.imported;\n          }\n          if (imported !== undefined) {\n            return imported.type === \"Identifier\"\n              ? imported.name !== \"default\"\n              : imported.value !== \"default\";\n          }\n        });\n        if (nonDefaultNamedSpecifier !== undefined) {\n          this.raise(Errors.ImportJSONBindingNotDefault, {\n            at: nonDefaultNamedSpecifier.loc.start,\n          });\n        }\n      }\n    }\n  }\n\n  isPotentialImportPhase(isExport: boolean): boolean {\n    return !isExport && this.isContextual(tt._module);\n  }\n\n  applyImportPhase(\n    node: Undone<N.ImportDeclaration | N.ExportNamedDeclaration>,\n    isExport: boolean,\n    phase: string | null,\n    loc?: Position,\n  ): void {\n    if (isExport) {\n      if (!process.env.IS_PUBLISH) {\n        if (phase === \"module\") {\n          throw new Error(\n            \"Assertion failure: export declarations do not support the 'module' phase.\",\n          );\n        }\n      }\n      return;\n    }\n    if (phase === \"module\") {\n      this.expectPlugin(\"importReflection\", loc);\n      (node as N.ImportDeclaration).module = true;\n    } else if (this.hasPlugin(\"importReflection\")) {\n      (node as N.ImportDeclaration).module = false;\n    }\n  }\n\n  /*\n   * Parse `module` in `import module x fro \"x\"`, disambiguating\n   * `import module from \"x\"` and `import module from from \"x\"`.\n   *\n   * This function might return an identifier representing the `module`\n   * if it eats `module` and then discovers that it was the default import\n   * binding and not the import reflection.\n   *\n   * This function is also used to parse `import type` and `import typeof`\n   * in the TS and Flow plugins.\n   *\n   * Note: the proposal has been updated to use `source` instead of `module`,\n   * but it has not been implemented yet.\n   */\n  parseMaybeImportPhase(\n    node: Undone<N.ImportDeclaration | N.TsImportEqualsDeclaration>,\n    isExport: boolean,\n  ): N.Identifier | null {\n    if (!this.isPotentialImportPhase(isExport)) {\n      this.applyImportPhase(\n        node as Undone<N.ImportDeclaration>,\n        isExport,\n        null,\n      );\n      return null;\n    }\n\n    const phaseIdentifier = this.parseIdentifier(true);\n\n    const { type } = this.state;\n    const isImportPhase = tokenIsKeywordOrIdentifier(type)\n      ? // OK: import <phase> x from \"foo\";\n        // OK: import <phase> from from \"foo\";\n        // NO: import <phase> from \"foo\";\n        // NO: import <phase> from 'foo';\n        // With the module declarations proposals, we will need further disambiguation\n        // for `import module from from;`.\n        type !== tt._from || this.lookaheadCharCode() === charCodes.lowercaseF\n      : // OK: import <phase> { x } from \"foo\";\n        // OK: import <phase> x from \"foo\";\n        // OK: import <phase> * as T from \"foo\";\n        // NO: import <phase> from \"foo\";\n        // OK: import <phase> \"foo\";\n        // The last one is invalid, we will continue parsing and throw\n        // an error later\n        type !== tt.comma;\n\n    if (isImportPhase) {\n      this.resetPreviousIdentifierLeadingComments(phaseIdentifier);\n      this.applyImportPhase(\n        node as Undone<N.ImportDeclaration>,\n        isExport,\n        phaseIdentifier.name,\n        phaseIdentifier.loc.start,\n      );\n      return null;\n    } else {\n      this.applyImportPhase(\n        node as Undone<N.ImportDeclaration>,\n        isExport,\n        null,\n      );\n      // `<phase>` is a default binding, return it to the main import declaration parser\n      return phaseIdentifier;\n    }\n  }\n\n  isPrecedingIdImportPhase(\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    phase: string,\n  ) {\n    const { type } = this.state;\n    return tokenIsIdentifier(type)\n      ? // OK: import <phase> x from \"foo\";\n        // OK: import <phase> from from \"foo\";\n        // NO: import <phase> from \"foo\";\n        // NO: import <phase> from 'foo';\n        // With the module declarations proposals, we will need further disambiguation\n        // for `import module from from;`.\n        type !== tt._from || this.lookaheadCharCode() === charCodes.lowercaseF\n      : // OK: import <phase> { x } from \"foo\";\n        // OK: import <phase> x from \"foo\";\n        // OK: import <phase> * as T from \"foo\";\n        // NO: import <phase> from \"foo\";\n        // OK: import <phase> \"foo\";\n        // The last one is invalid, we will continue parsing and throw\n        // an error later\n        type !== tt.comma;\n  }\n\n  // Parses import declaration.\n  // https://tc39.es/ecma262/#prod-ImportDeclaration\n\n  parseImport(this: Parser, node: Undone<N.ImportDeclaration>): N.AnyImport {\n    if (this.match(tt.string)) {\n      // import '...'\n      return this.parseImportSourceAndAttributes(node);\n    }\n\n    return this.parseImportSpecifiersAndAfter(\n      node,\n      this.parseMaybeImportPhase(node, /* isExport */ false),\n    );\n  }\n\n  parseImportSpecifiersAndAfter(\n    this: Parser,\n    node: Undone<N.ImportDeclaration>,\n    maybeDefaultIdentifier: N.Identifier | null,\n  ): N.AnyImport {\n    node.specifiers = [];\n\n    // check if we have a default import like\n    // import React from \"react\";\n    const hasDefault = this.maybeParseDefaultImportSpecifier(\n      node,\n      maybeDefaultIdentifier,\n    );\n    /* we are checking if we do not have a default import, then it is obvious that we need named imports\n     * import { get } from \"axios\";\n     * but if we do have a default import\n     * we need to check if we have a comma after that and\n     * that is where this `|| this.eat` condition comes into play\n     */\n    const parseNext = !hasDefault || this.eat(tt.comma);\n    // if we do have to parse the next set of specifiers, we first check for star imports\n    // import React, * from \"react\";\n    const hasStar = parseNext && this.maybeParseStarImportSpecifier(node);\n    // now we check if we need to parse the next imports\n    // but only if they are not importing * (everything)\n    if (parseNext && !hasStar) this.parseNamedImportSpecifiers(node);\n    this.expectContextual(tt._from);\n\n    return this.parseImportSourceAndAttributes(node);\n  }\n\n  parseImportSourceAndAttributes(\n    this: Parser,\n    node: Undone<N.ImportDeclaration>,\n  ): N.AnyImport {\n    node.specifiers ??= [];\n    node.source = this.parseImportSource();\n    this.maybeParseImportAttributes(node);\n    this.checkImportReflection(node);\n    this.checkJSONModuleImport(node);\n\n    this.semicolon();\n    return this.finishNode(node, \"ImportDeclaration\");\n  }\n\n  parseImportSource(this: Parser): N.StringLiteral {\n    if (!this.match(tt.string)) this.unexpected();\n    return this.parseExprAtom() as N.StringLiteral;\n  }\n\n  parseImportSpecifierLocal<\n    T extends\n      | N.ImportSpecifier\n      | N.ImportDefaultSpecifier\n      | N.ImportNamespaceSpecifier,\n  >(\n    node: Undone<N.ImportDeclaration>,\n    specifier: Undone<T>,\n    type: T[\"type\"],\n  ): void {\n    specifier.local = this.parseIdentifier();\n    node.specifiers.push(this.finishImportSpecifier(specifier, type));\n  }\n\n  finishImportSpecifier<\n    T extends\n      | N.ImportSpecifier\n      | N.ImportDefaultSpecifier\n      | N.ImportNamespaceSpecifier,\n  >(specifier: Undone<T>, type: T[\"type\"], bindingType = BIND_LEXICAL) {\n    this.checkLVal(specifier.local, {\n      in: { type },\n      binding: bindingType,\n    });\n    return this.finishNode(specifier, type);\n  }\n\n  /**\n   * parse assert entries\n   *\n   * @see {@link https://tc39.es/proposal-import-attributes/#prod-WithEntries WithEntries}\n   */\n  parseImportAttributes(): N.ImportAttribute[] {\n    this.expect(tt.braceL);\n\n    const attrs = [];\n    const attrNames = new Set();\n\n    do {\n      if (this.match(tt.braceR)) {\n        break;\n      }\n\n      const node = this.startNode<N.ImportAttribute>();\n\n      // parse AssertionKey : IdentifierName, StringLiteral\n      const keyName = this.state.value;\n      // check if we already have an entry for an attribute\n      // if a duplicate entry is found, throw an error\n      // for now this logic will come into play only when someone declares `type` twice\n      if (attrNames.has(keyName)) {\n        this.raise(Errors.ModuleAttributesWithDuplicateKeys, {\n          at: this.state.startLoc,\n          key: keyName,\n        });\n      }\n      attrNames.add(keyName);\n      if (this.match(tt.string)) {\n        node.key = this.parseStringLiteral(keyName);\n      } else {\n        node.key = this.parseIdentifier(true);\n      }\n      this.expect(tt.colon);\n\n      if (!this.match(tt.string)) {\n        throw this.raise(Errors.ModuleAttributeInvalidValue, {\n          at: this.state.startLoc,\n        });\n      }\n      node.value = this.parseStringLiteral(this.state.value);\n      attrs.push(this.finishNode(node, \"ImportAttribute\"));\n    } while (this.eat(tt.comma));\n\n    this.expect(tt.braceR);\n\n    return attrs;\n  }\n\n  /**\n   * parse module attributes\n   * @deprecated It will be removed in Babel 8\n   */\n  parseModuleAttributes() {\n    const attrs: N.ImportAttribute[] = [];\n    const attributes = new Set();\n    do {\n      const node = this.startNode<N.ImportAttribute>();\n      node.key = this.parseIdentifier(true);\n\n      if (node.key.name !== \"type\") {\n        this.raise(Errors.ModuleAttributeDifferentFromType, {\n          at: node.key,\n        });\n      }\n\n      if (attributes.has(node.key.name)) {\n        this.raise(Errors.ModuleAttributesWithDuplicateKeys, {\n          at: node.key,\n          key: node.key.name,\n        });\n      }\n      attributes.add(node.key.name);\n      this.expect(tt.colon);\n      if (!this.match(tt.string)) {\n        throw this.raise(Errors.ModuleAttributeInvalidValue, {\n          at: this.state.startLoc,\n        });\n      }\n      node.value = this.parseStringLiteral(this.state.value);\n      attrs.push(this.finishNode(node, \"ImportAttribute\"));\n    } while (this.eat(tt.comma));\n\n    return attrs;\n  }\n\n  maybeParseImportAttributes(\n    node: Undone<N.ImportDeclaration | N.ExportNamedDeclaration>,\n  ) {\n    let attributes: N.ImportAttribute[];\n    let useWith = false;\n\n    // https://tc39.es/proposal-import-attributes/#prod-WithClause\n    if (this.match(tt._with)) {\n      if (\n        this.hasPrecedingLineBreak() &&\n        this.lookaheadCharCode() === charCodes.leftParenthesis\n      ) {\n        // This will be parsed as a with statement, and we will throw a\n        // better error about it not being supported in strict mode.\n        return;\n      }\n\n      this.next(); // eat `with`\n\n      if (!process.env.BABEL_8_BREAKING) {\n        if (this.hasPlugin(\"moduleAttributes\")) {\n          attributes = this.parseModuleAttributes();\n        } else {\n          this.expectImportAttributesPlugin();\n          attributes = this.parseImportAttributes();\n        }\n      } else {\n        this.expectImportAttributesPlugin();\n        attributes = this.parseImportAttributes();\n      }\n      useWith = true;\n    } else if (this.isContextual(tt._assert) && !this.hasPrecedingLineBreak()) {\n      if (this.hasPlugin(\"importAttributes\")) {\n        if (\n          this.getPluginOption(\"importAttributes\", \"deprecatedAssertSyntax\") !==\n          true\n        ) {\n          this.raise(Errors.ImportAttributesUseAssert, {\n            at: this.state.startLoc,\n          });\n        }\n        this.addExtra(node, \"deprecatedAssertSyntax\", true);\n      } else {\n        this.expectOnePlugin([\"importAttributes\", \"importAssertions\"]);\n      }\n      this.next(); // eat `assert`\n      attributes = this.parseImportAttributes();\n    } else if (\n      this.hasPlugin(\"importAttributes\") ||\n      this.hasPlugin(\"importAssertions\")\n    ) {\n      attributes = [];\n    } else if (!process.env.BABEL_8_BREAKING) {\n      if (this.hasPlugin(\"moduleAttributes\")) {\n        attributes = [];\n      } else return;\n    } else return;\n\n    if (!useWith && this.hasPlugin(\"importAssertions\")) {\n      node.assertions = attributes;\n    } else {\n      node.attributes = attributes;\n    }\n  }\n\n  maybeParseDefaultImportSpecifier(\n    node: Undone<N.ImportDeclaration>,\n    maybeDefaultIdentifier: N.Identifier | null,\n  ): boolean {\n    // import defaultObj, { x, y as z } from '...'\n    if (maybeDefaultIdentifier) {\n      const specifier = this.startNodeAtNode<N.ImportDefaultSpecifier>(\n        maybeDefaultIdentifier,\n      );\n      specifier.local = maybeDefaultIdentifier;\n      node.specifiers.push(\n        this.finishImportSpecifier(specifier, \"ImportDefaultSpecifier\"),\n      );\n      return true;\n    } else if (\n      // We allow keywords, and parseImportSpecifierLocal will report a recoverable error\n      tokenIsKeywordOrIdentifier(this.state.type)\n    ) {\n      this.parseImportSpecifierLocal(\n        node,\n        this.startNode<N.ImportDefaultSpecifier>(),\n        \"ImportDefaultSpecifier\",\n      );\n      return true;\n    }\n    return false;\n  }\n\n  maybeParseStarImportSpecifier(node: Undone<N.ImportDeclaration>): boolean {\n    if (this.match(tt.star)) {\n      const specifier = this.startNode<N.ImportNamespaceSpecifier>();\n      this.next();\n      this.expectContextual(tt._as);\n\n      this.parseImportSpecifierLocal(\n        node,\n        specifier,\n        \"ImportNamespaceSpecifier\",\n      );\n      return true;\n    }\n    return false;\n  }\n\n  parseNamedImportSpecifiers(node: Undone<N.ImportDeclaration>) {\n    let first = true;\n    this.expect(tt.braceL);\n    while (!this.eat(tt.braceR)) {\n      if (first) {\n        first = false;\n      } else {\n        // Detect an attempt to deep destructure\n        if (this.eat(tt.colon)) {\n          throw this.raise(Errors.DestructureNamedImport, {\n            at: this.state.startLoc,\n          });\n        }\n\n        this.expect(tt.comma);\n        if (this.eat(tt.braceR)) break;\n      }\n\n      const specifier = this.startNode<N.ImportSpecifier>();\n      const importedIsString = this.match(tt.string);\n      const isMaybeTypeOnly = this.isContextual(tt._type);\n      specifier.imported = this.parseModuleExportName();\n      const importSpecifier = this.parseImportSpecifier(\n        specifier,\n        importedIsString,\n        node.importKind === \"type\" || node.importKind === \"typeof\",\n        isMaybeTypeOnly,\n        undefined,\n      );\n      node.specifiers.push(importSpecifier);\n    }\n  }\n\n  // https://tc39.es/ecma262/#prod-ImportSpecifier\n  parseImportSpecifier(\n    specifier: Undone<N.ImportSpecifier>,\n    importedIsString: boolean,\n    /* eslint-disable @typescript-eslint/no-unused-vars -- used in TypeScript and Flow parser */\n    isInTypeOnlyImport: boolean,\n    isMaybeTypeOnly: boolean,\n    bindingType: BindingTypes | undefined,\n    /* eslint-enable @typescript-eslint/no-unused-vars */\n  ): N.ImportSpecifier {\n    if (this.eatContextual(tt._as)) {\n      specifier.local = this.parseIdentifier();\n    } else {\n      const { imported } = specifier;\n      if (importedIsString) {\n        throw this.raise(Errors.ImportBindingIsString, {\n          at: specifier,\n          importName: (imported as N.StringLiteral).value,\n        });\n      }\n      this.checkReservedWord(\n        (imported as N.Identifier).name,\n        specifier.loc.start,\n        true,\n        true,\n      );\n      if (!specifier.local) {\n        specifier.local = cloneIdentifier(imported);\n      }\n    }\n    return this.finishImportSpecifier(\n      specifier,\n      \"ImportSpecifier\",\n      bindingType,\n    );\n  }\n\n  // This is used in flow and typescript plugin\n  // Determine whether a parameter is a this param\n  isThisParam(\n    param: N.Pattern | N.Identifier | N.TSParameterProperty,\n  ): boolean {\n    return param.type === \"Identifier\" && param.name === \"this\";\n  }\n}\n"],"mappings":"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"}���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������lib/parser/util.js����������������������������������������������������������������������������������0000644�����������������00000015706�15120211212�0010115 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = exports.ExpressionErrors = void 0;
var _types = require("../tokenizer/types");
var _tokenizer = require("../tokenizer");
var _whitespace = require("../util/whitespace");
var _identifier = require("../util/identifier");
var _classScope = require("../util/class-scope");
var _expressionScope = require("../util/expression-scope");
var _scopeflags = require("../util/scopeflags");
var _productionParameter = require("../util/production-parameter");
var _parseError = require("../parse-error");
class UtilParser extends _tokenizer.default {
  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 !((0, _identifier.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, toParseError) {
    if (!this.eatContextual(token)) {
      if (toParseError != null) {
        throw this.raise(toParseError, {
          at: this.state.startLoc
        });
      }
      this.unexpected(null, token);
    }
  }
  canInsertSemicolon() {
    return this.match(137) || this.match(8) || this.hasPrecedingLineBreak();
  }
  hasPrecedingLineBreak() {
    return _whitespace.lineBreak.test(this.input.slice(this.state.lastTokEndLoc.index, this.state.start));
  }
  hasFollowingLineBreak() {
    _whitespace.skipWhiteSpaceToLineBreak.lastIndex = this.state.end;
    return _whitespace.skipWhiteSpaceToLineBreak.test(this.input);
  }
  isLineTerminator() {
    return this.eat(13) || this.canInsertSemicolon();
  }
  semicolon(allowAsi = true) {
    if (allowAsi ? this.isLineTerminator() : this.eat(13)) return;
    this.raise(_parseError.Errors.MissingSemicolon, {
      at: this.state.lastTokEndLoc
    });
  }
  expect(type, loc) {
    this.eat(type) || this.unexpected(loc, type);
  }
  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(_parseError.Errors.InvalidCoverInitializedName, {
        at: shorthandAssignLoc
      });
    }
    if (doubleProtoLoc != null) {
      this.raise(_parseError.Errors.DuplicateProto, {
        at: doubleProtoLoc
      });
    }
    if (privateKeyLoc != null) {
      this.raise(_parseError.Errors.UnexpectedPrivateField, {
        at: privateKeyLoc
      });
    }
    if (optionalParametersLoc != null) {
      this.unexpected(optionalParametersLoc);
    }
  }
  isLiteralPropertyName() {
    return (0, _types.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);
  }
  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, inModule);
    const oldProdParam = this.prodParam;
    this.prodParam = new _productionParameter.default();
    const oldClassScope = this.classScope;
    this.classScope = new _classScope.default(this);
    const oldExpressionScope = this.expressionScope;
    this.expressionScope = new _expressionScope.default(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 = _productionParameter.PARAM;
    if (this.inModule) {
      paramFlags |= _productionParameter.PARAM_AWAIT;
    }
    this.scope.enter(_scopeflags.SCOPE_PROGRAM);
    this.prodParam.enter(paramFlags);
  }
  checkDestructuringPrivate(refExpressionErrors) {
    const {
      privateKeyLoc
    } = refExpressionErrors;
    if (privateKeyLoc !== null) {
      this.expectPlugin("destructuringPrivate", privateKeyLoc);
    }
  }
}
exports.default = UtilParser;
class ExpressionErrors {
  constructor() {
    this.shorthandAssignLoc = null;
    this.doubleProtoLoc = null;
    this.privateKeyLoc = null;
    this.optionalParametersLoc = null;
  }
}
exports.ExpressionErrors = ExpressionErrors;

//# sourceMappingURL=util.js.map
����������������������������������������������������������lib/parser/util.js.map������������������������������������������������������������������������������0000644�����������������00000046707�15120211212�0010676 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������{"version":3,"names":["_types","require","_tokenizer","_whitespace","_identifier","_classScope","_expressionScope","_scopeflags","_productionParameter","_parseError","UtilParser","Tokenizer","addExtra","node","key","value","enumerable","extra","Object","defineProperty","isContextual","token","state","type","containsEsc","isUnparsedContextual","nameStart","name","nameEnd","length","input","slice","nextCh","charCodeAt","isIdentifierChar","isLookaheadContextual","next","nextTokenStart","eatContextual","expectContextual","toParseError","raise","at","startLoc","unexpected","canInsertSemicolon","match","hasPrecedingLineBreak","lineBreak","test","lastTokEndLoc","index","start","hasFollowingLineBreak","skipWhiteSpaceToLineBreak","lastIndex","end","isLineTerminator","eat","semicolon","allowAsi","Errors","MissingSemicolon","expect","loc","tryParse","fn","oldState","clone","abortSignal","errors","failState","tokensLength","error","thrown","aborted","SyntaxError","checkExpressionErrors","refExpressionErrors","andThrow","shorthandAssignLoc","doubleProtoLoc","privateKeyLoc","optionalParametersLoc","hasErrors","InvalidCoverInitializedName","DuplicateProto","UnexpectedPrivateField","isLiteralPropertyName","tokenIsLiteralPropertyName","isPrivateName","getPrivateNameSV","id","hasPropertyAsPrivateName","property","isObjectProperty","isObjectMethod","initializeScopes","inModule","options","sourceType","oldLabels","labels","oldExportedIdentifiers","exportedIdentifiers","Set","oldInModule","oldScope","scope","ScopeHandler","getScopeHandler","oldProdParam","prodParam","ProductionParameterHandler","oldClassScope","classScope","ClassScopeHandler","oldExpressionScope","expressionScope","ExpressionScopeHandler","enterInitialScopes","paramFlags","PARAM","PARAM_AWAIT","enter","SCOPE_PROGRAM","checkDestructuringPrivate","expectPlugin","exports","default","ExpressionErrors","constructor"],"sources":["../../src/parser/util.ts"],"sourcesContent":["import type { Position } from \"../util/location\";\nimport {\n  tokenIsLiteralPropertyName,\n  tt,\n  type TokenType,\n} from \"../tokenizer/types\";\nimport Tokenizer from \"../tokenizer\";\nimport type State from \"../tokenizer/state\";\nimport type { EstreePropertyDefinition, Node, ObjectProperty } from \"../types\";\nimport { lineBreak, skipWhiteSpaceToLineBreak } from \"../util/whitespace\";\nimport { isIdentifierChar } from \"../util/identifier\";\nimport ClassScopeHandler from \"../util/class-scope\";\nimport ExpressionScopeHandler from \"../util/expression-scope\";\nimport { SCOPE_PROGRAM } from \"../util/scopeflags\";\nimport ProductionParameterHandler, {\n  PARAM_AWAIT,\n  PARAM,\n} from \"../util/production-parameter\";\nimport {\n  Errors,\n  type ParseError,\n  type ParseErrorConstructor,\n} from \"../parse-error\";\nimport type Parser from \".\";\n\nimport type ScopeHandler from \"../util/scope\";\n\ntype TryParse<Node, Error, Thrown, Aborted, FailState> = {\n  node: Node;\n  error: Error;\n  thrown: Thrown;\n  aborted: Aborted;\n  failState: FailState;\n};\n\n// ## Parser utilities\n\nexport default abstract class UtilParser extends Tokenizer {\n  // Forward-declaration: defined in parser/index.js\n  abstract getScopeHandler(): { new (...args: any): ScopeHandler };\n\n  addExtra(\n    node: Partial<Node>,\n    key: string,\n    value: any,\n    enumerable: boolean = true,\n  ): void {\n    if (!node) return;\n\n    const extra = (node.extra = node.extra || {});\n    if (enumerable) {\n      extra[key] = value;\n    } else {\n      Object.defineProperty(extra, key, { enumerable, value });\n    }\n  }\n\n  // Tests whether parsed token is a contextual keyword.\n\n  isContextual(token: TokenType): boolean {\n    return this.state.type === token && !this.state.containsEsc;\n  }\n\n  isUnparsedContextual(nameStart: number, name: string): boolean {\n    const nameEnd = nameStart + name.length;\n    if (this.input.slice(nameStart, nameEnd) === name) {\n      const nextCh = this.input.charCodeAt(nameEnd);\n      return !(\n        isIdentifierChar(nextCh) ||\n        // check if `nextCh is between 0xd800 - 0xdbff,\n        // if `nextCh` is NaN, `NaN & 0xfc00` is 0, the function\n        // returns true\n        (nextCh & 0xfc00) === 0xd800\n      );\n    }\n    return false;\n  }\n\n  isLookaheadContextual(name: string): boolean {\n    const next = this.nextTokenStart();\n    return this.isUnparsedContextual(next, name);\n  }\n\n  // Consumes contextual keyword if possible.\n\n  eatContextual(token: TokenType): boolean {\n    if (this.isContextual(token)) {\n      this.next();\n      return true;\n    }\n    return false;\n  }\n\n  // Asserts that following token is given contextual keyword.\n\n  expectContextual(\n    token: TokenType,\n    toParseError?: ParseErrorConstructor<any>,\n  ): void {\n    if (!this.eatContextual(token)) {\n      if (toParseError != null) {\n        throw this.raise(toParseError, { at: this.state.startLoc });\n      }\n      this.unexpected(null, token);\n    }\n  }\n\n  // Test whether a semicolon can be inserted at the current position.\n\n  canInsertSemicolon(): boolean {\n    return (\n      this.match(tt.eof) ||\n      this.match(tt.braceR) ||\n      this.hasPrecedingLineBreak()\n    );\n  }\n\n  hasPrecedingLineBreak(): boolean {\n    return lineBreak.test(\n      this.input.slice(this.state.lastTokEndLoc.index, this.state.start),\n    );\n  }\n\n  hasFollowingLineBreak(): boolean {\n    skipWhiteSpaceToLineBreak.lastIndex = this.state.end;\n    return skipWhiteSpaceToLineBreak.test(this.input);\n  }\n\n  isLineTerminator(): boolean {\n    return this.eat(tt.semi) || this.canInsertSemicolon();\n  }\n\n  // Consume a semicolon, or, failing that, see if we are allowed to\n  // pretend that there is a semicolon at this position.\n\n  semicolon(allowAsi: boolean = true): void {\n    if (allowAsi ? this.isLineTerminator() : this.eat(tt.semi)) return;\n    this.raise(Errors.MissingSemicolon, { at: this.state.lastTokEndLoc });\n  }\n\n  // Expect a token of a given type. If found, consume it, otherwise,\n  // raise an unexpected token error at given pos.\n\n  expect(type: TokenType, loc?: Position | null): void {\n    this.eat(type) || this.unexpected(loc, type);\n  }\n\n  // tryParse will clone parser state.\n  // It is expensive and should be used with cautions\n  tryParse<T extends Node | ReadonlyArray<Node>>(\n    fn: (abort: (node?: T) => never) => T,\n    oldState: State = this.state.clone(),\n  ):\n    | TryParse<T, null, false, false, null>\n    | TryParse<T | null, ParseError<any>, boolean, false, State>\n    | TryParse<T | null, null, false, true, State> {\n    const abortSignal: {\n      node: T | null;\n    } = { node: null };\n    try {\n      const node = fn((node = null) => {\n        abortSignal.node = node;\n        throw abortSignal;\n      });\n      if (this.state.errors.length > oldState.errors.length) {\n        const failState = this.state;\n        this.state = oldState;\n        // tokensLength should be preserved during error recovery mode\n        // since the parser does not halt and will instead parse the\n        // remaining tokens\n        this.state.tokensLength = failState.tokensLength;\n        return {\n          node,\n          error: failState.errors[oldState.errors.length],\n          thrown: false,\n          aborted: false,\n          failState,\n        };\n      }\n\n      return {\n        node,\n        error: null,\n        thrown: false,\n        aborted: false,\n        failState: null,\n      };\n    } catch (error) {\n      const failState = this.state;\n      this.state = oldState;\n      if (error instanceof SyntaxError) {\n        // @ts-expect-error casting general syntax error to parse error\n        return { node: null, error, thrown: true, aborted: false, failState };\n      }\n      if (error === abortSignal) {\n        return {\n          node: abortSignal.node,\n          error: null,\n          thrown: false,\n          aborted: true,\n          failState,\n        };\n      }\n\n      throw error;\n    }\n  }\n\n  checkExpressionErrors(\n    refExpressionErrors: ExpressionErrors | undefined | null,\n    andThrow: boolean,\n  ) {\n    if (!refExpressionErrors) return false;\n    const {\n      shorthandAssignLoc,\n      doubleProtoLoc,\n      privateKeyLoc,\n      optionalParametersLoc,\n    } = refExpressionErrors;\n\n    const hasErrors =\n      !!shorthandAssignLoc ||\n      !!doubleProtoLoc ||\n      !!optionalParametersLoc ||\n      !!privateKeyLoc;\n\n    if (!andThrow) {\n      return hasErrors;\n    }\n\n    if (shorthandAssignLoc != null) {\n      this.raise(Errors.InvalidCoverInitializedName, {\n        at: shorthandAssignLoc,\n      });\n    }\n\n    if (doubleProtoLoc != null) {\n      this.raise(Errors.DuplicateProto, { at: doubleProtoLoc });\n    }\n\n    if (privateKeyLoc != null) {\n      this.raise(Errors.UnexpectedPrivateField, { at: privateKeyLoc });\n    }\n\n    if (optionalParametersLoc != null) {\n      this.unexpected(optionalParametersLoc);\n    }\n  }\n\n  /**\n   * Test if current token is a literal property name\n   * https://tc39.es/ecma262/#prod-LiteralPropertyName\n   * LiteralPropertyName:\n   *   IdentifierName\n   *   StringLiteral\n   *   NumericLiteral\n   *   BigIntLiteral\n   */\n  isLiteralPropertyName(): boolean {\n    return tokenIsLiteralPropertyName(this.state.type);\n  }\n\n  /**\n   * Test if given node is a PrivateName\n   * will be overridden in ESTree plugin\n   */\n  isPrivateName(node: Node): boolean {\n    return node.type === \"PrivateName\";\n  }\n\n  /**\n   * Return the string value of a given private name\n   * WITHOUT `#`\n   * @see {@link https://tc39.es/ecma262/#sec-static-semantics-stringvalue}\n   */\n  getPrivateNameSV(node: Node): string {\n    return node.id.name;\n  }\n\n  /**\n   * Return whether the given node is a member/optional chain that\n   * contains a private name as its property\n   * It is overridden in ESTree plugin\n   */\n  hasPropertyAsPrivateName(node: Node): boolean {\n    return (\n      (node.type === \"MemberExpression\" ||\n        node.type === \"OptionalMemberExpression\") &&\n      this.isPrivateName(node.property)\n    );\n  }\n\n  isObjectProperty(\n    node: Node,\n  ): node is ObjectProperty | EstreePropertyDefinition {\n    return node.type === \"ObjectProperty\";\n  }\n\n  isObjectMethod(node: Node): boolean {\n    return node.type === \"ObjectMethod\";\n  }\n\n  initializeScopes(\n    this: Parser,\n    inModule: boolean = this.options.sourceType === \"module\",\n  ): () => void {\n    // Initialize state\n    const oldLabels = this.state.labels;\n    this.state.labels = [];\n\n    const oldExportedIdentifiers = this.exportedIdentifiers;\n    this.exportedIdentifiers = new Set();\n\n    // initialize scopes\n    const oldInModule = this.inModule;\n    this.inModule = inModule;\n\n    const oldScope = this.scope;\n    const ScopeHandler = this.getScopeHandler();\n    this.scope = new ScopeHandler(this, inModule);\n\n    const oldProdParam = this.prodParam;\n    this.prodParam = new ProductionParameterHandler();\n\n    const oldClassScope = this.classScope;\n    this.classScope = new ClassScopeHandler(this);\n\n    const oldExpressionScope = this.expressionScope;\n    this.expressionScope = new ExpressionScopeHandler(this);\n\n    return () => {\n      // Revert state\n      this.state.labels = oldLabels;\n      this.exportedIdentifiers = oldExportedIdentifiers;\n\n      // Revert scopes\n      this.inModule = oldInModule;\n      this.scope = oldScope;\n      this.prodParam = oldProdParam;\n      this.classScope = oldClassScope;\n      this.expressionScope = oldExpressionScope;\n    };\n  }\n\n  enterInitialScopes() {\n    let paramFlags = PARAM;\n    if (this.inModule) {\n      paramFlags |= PARAM_AWAIT;\n    }\n    this.scope.enter(SCOPE_PROGRAM);\n    this.prodParam.enter(paramFlags);\n  }\n\n  checkDestructuringPrivate(refExpressionErrors: ExpressionErrors) {\n    const { privateKeyLoc } = refExpressionErrors;\n    if (privateKeyLoc !== null) {\n      this.expectPlugin(\"destructuringPrivate\", privateKeyLoc);\n    }\n  }\n}\n\n/**\n * The ExpressionErrors is a context struct used to track ambiguous patterns\n * When we are sure the parsed pattern is a RHS, which means it is not a pattern,\n * we will throw on this position on invalid assign syntax, otherwise it will be reset to -1\n *\n * Types of ExpressionErrors:\n *\n * - **shorthandAssignLoc**: track initializer `=` position\n * - **doubleProtoLoc**: track the duplicate `__proto__` key position\n * - **privateKey**: track private key `#p` position\n * - **optionalParametersLoc**: track the optional parameter (`?`).\n * It's only used by typescript and flow plugins\n */\nexport class ExpressionErrors {\n  shorthandAssignLoc: Position | undefined | null = null;\n  doubleProtoLoc: Position | undefined | null = null;\n  privateKeyLoc: Position | undefined | null = null;\n  optionalParametersLoc: Position | undefined | null = null;\n}\n"],"mappings":"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"}���������������������������������������������������������lib/plugin-utils.js���������������������������������������������������������������������������������0000644�����������������00000014175�15120211212�0010277 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.getPluginOption = getPluginOption;
exports.hasPlugin = hasPlugin;
exports.mixinPlugins = exports.mixinPluginNames = void 0;
exports.validatePlugins = validatePlugins;
var _estree = require("./plugins/estree");
var _flow = require("./plugins/flow");
var _jsx = require("./plugins/jsx");
var _typescript = require("./plugins/typescript");
var _placeholders = require("./plugins/placeholders");
var _v8intrinsic = require("./plugins/v8intrinsic");
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) && plugin.length > 1) {
    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 && typeof decoratorsBeforeExport !== "boolean") {
      throw new Error("'decoratorsBeforeExport' must be a boolean, if specified.");
    }
    const allowCallParenthesized = getPluginOption(plugins, "decorators", "allowCallParenthesized");
    if (allowCallParenthesized != null && typeof allowCallParenthesized !== "boolean") {
      throw new Error("'allowCallParenthesized' 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") || hasPlugin(plugins, "importAttributes")) {
        throw new Error("Cannot combine importAssertions, importAttributes and moduleAttributes plugins.");
      }
      const moduleAttributesVersionPluginOption = getPluginOption(plugins, "moduleAttributes", "version");
      if (moduleAttributesVersionPluginOption !== "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, "importAssertions") && hasPlugin(plugins, "importAttributes")) {
    throw new Error("Cannot combine importAssertions and importAttributes plugins.");
  }
  if (hasPlugin(plugins, "recordAndTuple") && getPluginOption(plugins, "recordAndTuple", "syntaxType") != null && !RECORD_AND_TUPLE_SYNTAX_TYPES.includes(getPluginOption(plugins, "recordAndTuple", "syntaxType"))) {
    throw new Error("The 'syntaxType' option of the 'recordAndTuple' plugin must 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: _estree.default,
  jsx: _jsx.default,
  flow: _flow.default,
  typescript: _typescript.default,
  v8intrinsic: _v8intrinsic.default,
  placeholders: _placeholders.default
};
exports.mixinPlugins = mixinPlugins;
const mixinPluginNames = Object.keys(mixinPlugins);
exports.mixinPluginNames = mixinPluginNames;

//# sourceMappingURL=plugin-utils.js.map
���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������lib/plugin-utils.js.map�����������������������������������������������������������������������������0000644�����������������00000033330�15120211212�0011045 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������{"version":3,"names":["_estree","require","_flow","_jsx","_typescript","_placeholders","_v8intrinsic","hasPlugin","plugins","expectedConfig","expectedName","expectedOptions","expectedKeys","Object","keys","expectedOptionsIsEmpty","length","some","p","pluginName","pluginOptions","key","getPluginOption","name","option","plugin","find","Array","isArray","PIPELINE_PROPOSALS","TOPIC_TOKENS","RECORD_AND_TUPLE_SYNTAX_TYPES","validatePlugins","Error","decoratorsBeforeExport","allowCallParenthesized","proposal","includes","proposalList","map","join","tupleSyntaxIsHash","syntaxType","topicToken","tokenList","t","moduleAttributesVersionPluginOption","error","missingPlugins","mixinPlugins","estree","jsx","flow","typescript","v8intrinsic","placeholders","exports","mixinPluginNames"],"sources":["../src/plugin-utils.ts"],"sourcesContent":["import type Parser from \"./parser\";\nimport type {\n  ParserPluginWithOptions,\n  PluginConfig,\n  PluginOptions,\n} from \"./typings\";\n\nexport type Plugin = PluginConfig;\n\nexport type PluginList = PluginConfig[];\n\nexport type MixinPlugin = (superClass: { new (...args: any): Parser }) => {\n  new (...args: any): Parser;\n};\n\n// This function’s second parameter accepts either a string (plugin name) or an\n// array pair (plugin name and options object). If an options object is given,\n// then each value is non-recursively checked for identity with the actual\n// option value of each plugin in the first argument (which is an array of\n// plugin names or array pairs).\nexport function hasPlugin(\n  plugins: PluginList,\n  expectedConfig: PluginConfig,\n): boolean {\n  // The expectedOptions object is by default an empty object if the given\n  // expectedConfig argument does not give an options object (i.e., if it is a\n  // string).\n  const [expectedName, expectedOptions] =\n    typeof expectedConfig === \"string\" ? [expectedConfig, {}] : expectedConfig;\n\n  const expectedKeys = Object.keys(expectedOptions);\n\n  const expectedOptionsIsEmpty = expectedKeys.length === 0;\n\n  return plugins.some(p => {\n    if (typeof p === \"string\") {\n      return expectedOptionsIsEmpty && p === expectedName;\n    } else {\n      const [pluginName, pluginOptions] = p;\n      if (pluginName !== expectedName) {\n        return false;\n      }\n      for (const key of expectedKeys) {\n        // @ts-expect-error key may not exist in plugin options\n        if (pluginOptions[key] !== expectedOptions[key]) {\n          return false;\n        }\n      }\n      return true;\n    }\n  });\n}\n\nexport function getPluginOption<\n  PluginName extends ParserPluginWithOptions[0],\n  OptionName extends keyof PluginOptions<PluginName>,\n>(plugins: PluginList, name: PluginName, option: OptionName) {\n  const plugin = plugins.find(plugin => {\n    if (Array.isArray(plugin)) {\n      return plugin[0] === name;\n    } else {\n      return plugin === name;\n    }\n  });\n\n  if (plugin && Array.isArray(plugin) && plugin.length > 1) {\n    return (plugin[1] as PluginOptions<PluginName>)[option];\n  }\n\n  return null;\n}\n\nconst PIPELINE_PROPOSALS = [\"minimal\", \"fsharp\", \"hack\", \"smart\"];\nconst TOPIC_TOKENS = [\"^^\", \"@@\", \"^\", \"%\", \"#\"];\nconst RECORD_AND_TUPLE_SYNTAX_TYPES = [\"hash\", \"bar\"];\n\nexport function validatePlugins(plugins: PluginList) {\n  if (hasPlugin(plugins, \"decorators\")) {\n    if (hasPlugin(plugins, \"decorators-legacy\")) {\n      throw new Error(\n        \"Cannot use the decorators and decorators-legacy plugin together\",\n      );\n    }\n\n    const decoratorsBeforeExport = getPluginOption(\n      plugins,\n      \"decorators\",\n      \"decoratorsBeforeExport\",\n    );\n    if (\n      decoratorsBeforeExport != null &&\n      typeof decoratorsBeforeExport !== \"boolean\"\n    ) {\n      throw new Error(\n        \"'decoratorsBeforeExport' must be a boolean, if specified.\",\n      );\n    }\n\n    const allowCallParenthesized = getPluginOption(\n      plugins,\n      \"decorators\",\n      \"allowCallParenthesized\",\n    );\n    if (\n      allowCallParenthesized != null &&\n      typeof allowCallParenthesized !== \"boolean\"\n    ) {\n      throw new Error(\"'allowCallParenthesized' must be a boolean.\");\n    }\n  }\n\n  if (hasPlugin(plugins, \"flow\") && hasPlugin(plugins, \"typescript\")) {\n    throw new Error(\"Cannot combine flow and typescript plugins.\");\n  }\n\n  if (hasPlugin(plugins, \"placeholders\") && hasPlugin(plugins, \"v8intrinsic\")) {\n    throw new Error(\"Cannot combine placeholders and v8intrinsic plugins.\");\n  }\n\n  if (hasPlugin(plugins, \"pipelineOperator\")) {\n    const proposal = getPluginOption(plugins, \"pipelineOperator\", \"proposal\");\n\n    if (!PIPELINE_PROPOSALS.includes(proposal)) {\n      const proposalList = PIPELINE_PROPOSALS.map(p => `\"${p}\"`).join(\", \");\n      throw new Error(\n        `\"pipelineOperator\" requires \"proposal\" option whose value must be one of: ${proposalList}.`,\n      );\n    }\n\n    const tupleSyntaxIsHash = hasPlugin(plugins, [\n      \"recordAndTuple\",\n      { syntaxType: \"hash\" },\n    ]);\n\n    if (proposal === \"hack\") {\n      if (hasPlugin(plugins, \"placeholders\")) {\n        throw new Error(\n          \"Cannot combine placeholders plugin and Hack-style pipes.\",\n        );\n      }\n\n      if (hasPlugin(plugins, \"v8intrinsic\")) {\n        throw new Error(\n          \"Cannot combine v8intrinsic plugin and Hack-style pipes.\",\n        );\n      }\n\n      const topicToken = getPluginOption(\n        plugins,\n        \"pipelineOperator\",\n        \"topicToken\",\n      );\n\n      if (!TOPIC_TOKENS.includes(topicToken)) {\n        const tokenList = TOPIC_TOKENS.map(t => `\"${t}\"`).join(\", \");\n\n        throw new Error(\n          `\"pipelineOperator\" in \"proposal\": \"hack\" mode also requires a \"topicToken\" option whose value must be one of: ${tokenList}.`,\n        );\n      }\n\n      if (topicToken === \"#\" && tupleSyntaxIsHash) {\n        throw new Error(\n          'Plugin conflict between `[\"pipelineOperator\", { proposal: \"hack\", topicToken: \"#\" }]` and `[\"recordAndtuple\", { syntaxType: \"hash\"}]`.',\n        );\n      }\n    } else if (proposal === \"smart\" && tupleSyntaxIsHash) {\n      throw new Error(\n        'Plugin conflict between `[\"pipelineOperator\", { proposal: \"smart\" }]` and `[\"recordAndtuple\", { syntaxType: \"hash\"}]`.',\n      );\n    }\n  }\n\n  if (hasPlugin(plugins, \"moduleAttributes\")) {\n    if (process.env.BABEL_8_BREAKING) {\n      throw new Error(\n        \"`moduleAttributes` has been removed in Babel 8, please use `importAttributes` parser plugin, or `@babel/plugin-syntax-import-attributes`.\",\n      );\n    } else {\n      if (\n        hasPlugin(plugins, \"importAssertions\") ||\n        hasPlugin(plugins, \"importAttributes\")\n      ) {\n        throw new Error(\n          \"Cannot combine importAssertions, importAttributes and moduleAttributes plugins.\",\n        );\n      }\n      const moduleAttributesVersionPluginOption = getPluginOption(\n        plugins,\n        \"moduleAttributes\",\n        \"version\",\n      );\n      if (moduleAttributesVersionPluginOption !== \"may-2020\") {\n        throw new Error(\n          \"The 'moduleAttributes' plugin requires a 'version' option,\" +\n            \" representing the last proposal update. Currently, the\" +\n            \" only supported value is 'may-2020'.\",\n        );\n      }\n    }\n  }\n  if (\n    hasPlugin(plugins, \"importAssertions\") &&\n    hasPlugin(plugins, \"importAttributes\")\n  ) {\n    throw new Error(\n      \"Cannot combine importAssertions and importAttributes plugins.\",\n    );\n  }\n\n  if (\n    hasPlugin(plugins, \"recordAndTuple\") &&\n    getPluginOption(plugins, \"recordAndTuple\", \"syntaxType\") != null &&\n    !RECORD_AND_TUPLE_SYNTAX_TYPES.includes(\n      getPluginOption(plugins, \"recordAndTuple\", \"syntaxType\"),\n    )\n  ) {\n    throw new Error(\n      \"The 'syntaxType' option of the 'recordAndTuple' plugin must be one of: \" +\n        RECORD_AND_TUPLE_SYNTAX_TYPES.map(p => `'${p}'`).join(\", \"),\n    );\n  }\n\n  if (\n    hasPlugin(plugins, \"asyncDoExpressions\") &&\n    !hasPlugin(plugins, \"doExpressions\")\n  ) {\n    const error = new Error(\n      \"'asyncDoExpressions' requires 'doExpressions', please add 'doExpressions' to parser plugins.\",\n    );\n    // @ts-expect-error so @babel/core can provide better error message\n    error.missingPlugins = \"doExpressions\";\n    throw error;\n  }\n}\n\n// These plugins are defined using a mixin which extends the parser class.\n\nimport estree from \"./plugins/estree\";\nimport flow from \"./plugins/flow\";\nimport jsx from \"./plugins/jsx\";\nimport typescript from \"./plugins/typescript\";\nimport placeholders from \"./plugins/placeholders\";\nimport v8intrinsic from \"./plugins/v8intrinsic\";\n\n// NOTE: order is important. estree must come first; placeholders must come last.\nexport const mixinPlugins = {\n  estree,\n  jsx,\n  flow,\n  typescript,\n  v8intrinsic,\n  placeholders,\n};\n\nexport const mixinPluginNames = Object.keys(mixinPlugins) as ReadonlyArray<\n  \"estree\" | \"jsx\" | \"flow\" | \"typescript\" | \"v8intrinsic\" | \"placeholders\"\n>;\n"],"mappings":"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"}��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������lib/plugins/estree.js�������������������������������������������������������������������������������0000644�����������������00000025052�15120211212�0010607 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;
var _parseError = require("../parse-error");
const {
  defineProperty
} = Object;
const toUnenumerable = (object, key) => defineProperty(object, key, {
  enumerable: false,
  value: object[key]
});
function toESTreeLocation(node) {
  node.loc.start && toUnenumerable(node.loc.start, "index");
  node.loc.end && toUnenumerable(node.loc.end, "index");
  return node;
}
var _default = superClass => class ESTreeParserMixin 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 expression = directive.value;
    delete directive.value;
    expression.type = "Literal";
    expression.raw = expression.extra.raw;
    expression.value = expression.extra.expressionValue;
    const stmt = directive;
    stmt.type = "ExpressionStatement";
    stmt.expression = expression;
    stmt.directive = expression.extra.rawValue;
    delete expression.extra;
    return stmt;
  }
  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, allowDirectives, topLevel, end, afterBlockParse) {
    super.parseBlockBody(node, allowDirectives, topLevel, end, afterBlockParse);
    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;
    }
    return this.finishNode(node, "MethodDefinition");
  }
  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, startLoc, isPattern, refExpressionErrors) {
    const node = super.parseObjectProperty(prop, startLoc, isPattern, refExpressionErrors);
    if (node) {
      node.kind = "init";
      node.type = "Property";
    }
    return node;
  }
  isValidLVal(type, isUnparenthesizedInAssign, binding) {
    return type === "Property" ? "value" : super.isValidLVal(type, isUnparenthesizedInAssign, binding);
  }
  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);
    } else {
      super.toAssignable(node, isLHS);
    }
  }
  toAssignableObjectExpressionProp(prop, isLast, isLHS) {
    if (prop.kind === "get" || prop.kind === "set") {
      this.raise(_parseError.Errors.PatternHasAccessor, {
        at: prop.key
      });
    } else if (prop.method) {
      this.raise(_parseError.Errors.PatternHasMethod, {
        at: prop.key
      });
    } else {
      super.toAssignableObjectExpressionProp(prop, isLast, isLHS);
    }
  }
  finishCallExpression(unfinished, optional) {
    const node = super.finishCallExpression(unfinished, optional);
    if (node.callee.type === "Import") {
      node.type = "ImportExpression";
      node.source = node.arguments[0];
      if (this.hasPlugin("importAttributes") || 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(unfinished, decorators) {
    const exportStartLoc = this.state.lastTokStartLoc;
    const node = super.parseExport(unfinished, decorators);
    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;
        }
      case "ExportDefaultDeclaration":
        {
          var _declaration$decorato;
          const {
            declaration
          } = node;
          if ((declaration == null ? void 0 : declaration.type) === "ClassDeclaration" && ((_declaration$decorato = declaration.decorators) == null ? void 0 : _declaration$decorato.length) > 0 && declaration.start === node.start) {
            this.resetStartLocation(node, exportStartLoc);
          }
        }
        break;
    }
    return node;
  }
  parseSubscript(base, startLoc, noCalls, state) {
    const node = super.parseSubscript(base, 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);
  }
  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));
  }
  resetStartLocation(node, startLoc) {
    super.resetStartLocation(node, startLoc);
    toESTreeLocation(node);
  }
  resetEndLocation(node, endLoc = this.state.lastTokEndLoc) {
    super.resetEndLocation(node, endLoc);
    toESTreeLocation(node);
  }
};
exports.default = _default;

//# sourceMappingURL=estree.js.map
��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������lib/plugins/estree.js.map���������������������������������������������������������������������������0000644�����������������00000076651�15120211212�0011376 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������{"version":3,"names":["_parseError","require","defineProperty","Object","toUnenumerable","object","key","enumerable","value","toESTreeLocation","node","loc","start","end","_default","superClass","ESTreeParserMixin","parse","file","options","tokens","map","parseRegExpLiteral","pattern","flags","regex","RegExp","e","estreeParseLiteral","parseBigIntLiteral","bigInt","BigInt","_unused","bigint","String","parseDecimalLiteral","decimal","parseLiteral","parseStringLiteral","parseNumericLiteral","parseNullLiteral","parseBooleanLiteral","directiveToStmt","directive","expression","type","raw","extra","expressionValue","stmt","rawValue","initFunction","isAsync","checkDeclaration","isObjectProperty","getObjectOrClassMethodParams","method","params","isValidDirective","_stmt$expression$extr","parenthesized","parseBlockBody","allowDirectives","topLevel","afterBlockParse","directiveStatements","directives","d","body","concat","pushClassMethod","classBody","isGenerator","isConstructor","allowsDirectSuper","parseMethod","typeParameters","push","parsePrivateName","getPluginOption","convertPrivateNameToPrivateIdentifier","name","getPrivateNameSV","id","isPrivateName","parseFunctionBody","allowExpression","isMethod","allowDirectSuper","inClassScope","funcNode","startNode","kind","computed","finishNode","parseClassProperty","args","propertyNode","parseClassPrivateProperty","parseObjectMethod","prop","isPattern","isAccessor","shorthand","parseObjectProperty","startLoc","refExpressionErrors","isValidLVal","isUnparenthesizedInAssign","binding","isAssignable","isBinding","toAssignable","isLHS","classScope","usePrivateName","toAssignableObjectExpressionProp","isLast","raise","Errors","PatternHasAccessor","at","PatternHasMethod","finishCallExpression","unfinished","optional","callee","source","arguments","hasPlugin","_node$arguments$","attributes","toReferencedArguments","parseExport","decorators","exportStartLoc","state","lastTokStartLoc","exported","specifiers","length","_declaration$decorato","declaration","resetStartLocation","parseSubscript","base","noCalls","optionalChainMember","substring","stop","chain","startNodeAtNode","hasPropertyAsPrivateName","isObjectMethod","finishNodeAt","endLoc","resetEndLocation","lastTokEndLoc","exports","default"],"sources":["../../src/plugins/estree.ts"],"sourcesContent":["import type { TokenType } from \"../tokenizer/types\";\nimport type Parser from \"../parser\";\nimport type { ExpressionErrors } from \"../parser/util\";\nimport type * as N from \"../types\";\nimport type { Node as NodeType, NodeBase, File } from \"../types\";\nimport type { Position } from \"../util/location\";\nimport { Errors } from \"../parse-error\";\nimport type { Undone } from \"../parser/node\";\nimport type { BindingTypes } from \"../util/scopeflags\";\n\nconst { defineProperty } = Object;\nconst toUnenumerable = (object: any, key: string) =>\n  defineProperty(object, key, { enumerable: false, value: object[key] });\n\nfunction toESTreeLocation(node: any) {\n  node.loc.start && toUnenumerable(node.loc.start, \"index\");\n  node.loc.end && toUnenumerable(node.loc.end, \"index\");\n\n  return node;\n}\n\nexport default (superClass: typeof Parser) =>\n  class ESTreeParserMixin extends superClass implements Parser {\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    // @ts-expect-error ESTree plugin changes node types\n    parseRegExpLiteral({ pattern, flags }): N.EstreeRegExpLiteral {\n      let regex: RegExp | null = 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<N.EstreeRegExpLiteral>(regex);\n      node.regex = { pattern, flags };\n\n      return node;\n    }\n\n    // @ts-expect-error ESTree plugin changes node types\n    parseBigIntLiteral(value: any): N.Node {\n      // https://github.com/estree/estree/blob/master/es2020.md#bigintliteral\n      let bigInt: BigInt | null;\n      try {\n        bigInt = BigInt(value);\n      } catch {\n        bigInt = null;\n      }\n      const node = this.estreeParseLiteral<N.EstreeBigIntLiteral>(bigInt);\n      node.bigint = String(node.value || value);\n\n      return node;\n    }\n\n    // @ts-expect-error ESTree plugin changes node types\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 = null;\n      const node = this.estreeParseLiteral(decimal);\n      node.decimal = String(node.value || value);\n\n      return node;\n    }\n\n    estreeParseLiteral<T extends N.Node>(value: any) {\n      // @ts-expect-error ESTree plugin changes node types\n      return this.parseLiteral<T>(value, \"Literal\");\n    }\n\n    // @ts-expect-error ESTree plugin changes node types\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    // @ts-expect-error ESTree plugin changes node types\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    // Cast a Directive to an ExpressionStatement. Mutates the input Directive.\n    directiveToStmt(directive: N.Directive): N.ExpressionStatement {\n      const expression = directive.value as any as N.EstreeLiteral;\n      delete directive.value;\n\n      expression.type = \"Literal\";\n      // @ts-expect-error N.EstreeLiteral.raw is not defined.\n      expression.raw = expression.extra.raw;\n      expression.value = expression.extra.expressionValue;\n\n      const stmt = directive as any as N.ExpressionStatement;\n      stmt.type = \"ExpressionStatement\";\n      stmt.expression = expression;\n      // @ts-expect-error N.ExpressionStatement.directive is not defined\n      stmt.directive = expression.extra.rawValue;\n\n      delete expression.extra;\n\n      return stmt;\n    }\n\n    // ==================================\n    // Overrides\n    // ==================================\n\n    initFunction(node: N.BodilessFunctionOrMethodBase, isAsync: boolean): 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        // @ts-expect-error plugin typings\n        this.checkDeclaration((node as unknown as N.EstreeProperty).value);\n      } else {\n        super.checkDeclaration(node);\n      }\n    }\n\n    getObjectOrClassMethodParams(method: N.ObjectMethod | N.ClassMethod) {\n      return (method as any as N.EstreeProperty | N.EstreeMethodDefinition)\n        .value.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      allowDirectives: boolean | undefined | null,\n      topLevel: boolean,\n      end: TokenType,\n      afterBlockParse?: (hasStrictModeDirective: boolean) => void,\n    ): void {\n      super.parseBlockBody(\n        node,\n        allowDirectives,\n        topLevel,\n        end,\n        afterBlockParse,\n      );\n\n      const directiveStatements = node.directives.map(d =>\n        this.directiveToStmt(d),\n      );\n      // @ts-expect-error estree plugin typings\n      node.body = directiveStatements.concat(node.body);\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        // @ts-expect-error mutate AST types\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 as any;\n      delete node.id;\n      // @ts-expect-error mutate AST types\n      node.name = name;\n      // @ts-expect-error mutate AST types\n      node.type = \"PrivateIdentifier\";\n      return node as unknown as N.EstreePrivateIdentifier;\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    // @ts-expect-error plugin may override interfaces\n    parseLiteral<T extends N.Literal>(value: any, type: T[\"type\"]): T {\n      const node = super.parseLiteral<T>(value, type);\n      // @ts-expect-error mutating AST types\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 | null,\n      isMethod: boolean = false,\n    ): void {\n      super.parseFunctionBody(node, allowExpression, isMethod);\n      node.expression = node.body.type !== \"BlockStatement\";\n    }\n\n    // @ts-expect-error plugin may override interfaces\n    parseMethod<\n      T extends N.ClassPrivateMethod | N.ObjectMethod | N.ClassMethod,\n    >(\n      node: Undone<T>,\n      isGenerator: boolean,\n      isAsync: boolean,\n      isConstructor: boolean,\n      allowDirectSuper: boolean,\n      type: T[\"type\"],\n      inClassScope: boolean = false,\n    ): N.EstreeMethodDefinition {\n      let funcNode = this.startNode<N.MethodLike>();\n      funcNode.kind = node.kind; // provide kind, so super method correctly sets state\n      funcNode = super.parseMethod(\n        // @ts-expect-error todo(flow->ts)\n        funcNode,\n        isGenerator,\n        isAsync,\n        isConstructor,\n        allowDirectSuper,\n        type,\n        inClassScope,\n      );\n      // @ts-expect-error mutate AST types\n      funcNode.type = \"FunctionExpression\";\n      delete funcNode.kind;\n      // @ts-expect-error mutate AST types\n      node.value = funcNode;\n      if (type === \"ClassPrivateMethod\") {\n        node.computed = false;\n      }\n      return this.finishNode(\n        // @ts-expect-error cast methods to estree types\n        node as Undone<N.EstreeMethodDefinition>,\n        \"MethodDefinition\",\n      );\n    }\n\n    parseClassProperty(...args: [N.ClassProperty]): any {\n      const propertyNode = super.parseClassProperty(...args) as any;\n      if (!process.env.BABEL_8_BREAKING) {\n        if (!this.getPluginOption(\"estree\", \"classFeatures\")) {\n          return propertyNode as N.EstreePropertyDefinition;\n        }\n      }\n      propertyNode.type = \"PropertyDefinition\";\n      return propertyNode as N.EstreePropertyDefinition;\n    }\n\n    parseClassPrivateProperty(...args: [N.ClassPrivateProperty]): any {\n      const propertyNode = super.parseClassPrivateProperty(...args) as any;\n      if (!process.env.BABEL_8_BREAKING) {\n        if (!this.getPluginOption(\"estree\", \"classFeatures\")) {\n          return propertyNode as N.EstreePropertyDefinition;\n        }\n      }\n      propertyNode.type = \"PropertyDefinition\";\n      propertyNode.computed = false;\n      return propertyNode as 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 | undefined | null {\n      const node: N.EstreeProperty = super.parseObjectMethod(\n        prop,\n        isGenerator,\n        isAsync,\n        isPattern,\n        isAccessor,\n      ) as any;\n\n      if (node) {\n        node.type = \"Property\";\n        if ((node as any as N.ClassMethod).kind === \"method\") {\n          node.kind = \"init\";\n        }\n        node.shorthand = false;\n      }\n\n      return node as any;\n    }\n\n    parseObjectProperty(\n      prop: N.ObjectProperty,\n      startLoc: Position | undefined | null,\n      isPattern: boolean,\n      refExpressionErrors?: ExpressionErrors | null,\n    ): N.ObjectProperty | undefined | null {\n      const node: N.EstreeProperty = super.parseObjectProperty(\n        prop,\n        startLoc,\n        isPattern,\n        refExpressionErrors,\n      ) as any;\n\n      if (node) {\n        node.kind = \"init\";\n        node.type = \"Property\";\n      }\n\n      return node as any;\n    }\n\n    isValidLVal(\n      type: string,\n      isUnparenthesizedInAssign: boolean,\n      binding: BindingTypes,\n    ) {\n      return type === \"Property\"\n        ? \"value\"\n        : super.isValidLVal(type, isUnparenthesizedInAssign, binding);\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): void {\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      } else {\n        super.toAssignable(node, isLHS);\n      }\n    }\n\n    toAssignableObjectExpressionProp(\n      prop: N.Node,\n      isLast: boolean,\n      isLHS: boolean,\n    ) {\n      if (prop.kind === \"get\" || prop.kind === \"set\") {\n        this.raise(Errors.PatternHasAccessor, { at: prop.key });\n      } else if (prop.method) {\n        this.raise(Errors.PatternHasMethod, { at: prop.key });\n      } else {\n        super.toAssignableObjectExpressionProp(prop, isLast, isLHS);\n      }\n    }\n\n    finishCallExpression<T extends N.CallExpression | N.OptionalCallExpression>(\n      unfinished: Undone<T>,\n      optional: boolean,\n    ): T {\n      const node = super.finishCallExpression(unfinished, optional);\n\n      if (node.callee.type === \"Import\") {\n        (node as N.Node as N.EstreeImportExpression).type = \"ImportExpression\";\n        (node as N.Node as N.EstreeImportExpression).source = node.arguments[0];\n        if (\n          this.hasPlugin(\"importAttributes\") ||\n          this.hasPlugin(\"importAssertions\")\n        ) {\n          (node as N.Node as N.EstreeImportExpression).attributes =\n            node.arguments[1] ?? null;\n        }\n        // arguments isn't optional in the type definition\n        delete node.arguments;\n        // 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(\n      unfinished: Undone<N.AnyExport>,\n      decorators: N.Decorator[] | null,\n    ) {\n      const exportStartLoc = this.state.lastTokStartLoc;\n      const node = super.parseExport(unfinished, decorators);\n\n      switch (node.type) {\n        case \"ExportAllDeclaration\":\n          // @ts-expect-error mutating AST types\n          node.exported = null;\n          break;\n\n        case \"ExportNamedDeclaration\":\n          if (\n            node.specifiers.length === 1 &&\n            // @ts-expect-error mutating AST types\n            node.specifiers[0].type === \"ExportNamespaceSpecifier\"\n          ) {\n            // @ts-expect-error mutating AST types\n            node.type = \"ExportAllDeclaration\";\n            // @ts-expect-error mutating AST types\n            node.exported = node.specifiers[0].exported;\n            delete node.specifiers;\n          }\n\n        // fallthrough\n        case \"ExportDefaultDeclaration\":\n          {\n            const { declaration } = node;\n            if (\n              declaration?.type === \"ClassDeclaration\" &&\n              declaration.decorators?.length > 0 &&\n              // decorator comes before export\n              declaration.start === node.start\n            ) {\n              this.resetStartLocation(\n                node,\n                // For compatibility with ESLint's keyword-spacing rule, which assumes that an\n                // export declaration must start with export.\n                // https://github.com/babel/babel/issues/15085\n                // Here we reset export declaration's start to be the start of the export token\n                exportStartLoc,\n              );\n            }\n          }\n\n          break;\n      }\n\n      return node;\n    }\n\n    parseSubscript(\n      base: N.Expression,\n      startLoc: Position,\n      noCalls: boolean | undefined | null,\n      state: N.ParseSubscriptState,\n    ) {\n      const node = super.parseSubscript(base, startLoc, noCalls, state);\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    // @ts-expect-error override interfaces\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<T extends NodeType>(\n      node: Undone<T>,\n      type: T[\"type\"],\n      endLoc: Position,\n    ): T {\n      return toESTreeLocation(super.finishNodeAt(node, type, endLoc));\n    }\n\n    resetStartLocation(node: N.Node, startLoc: Position) {\n      super.resetStartLocation(node, startLoc);\n      toESTreeLocation(node);\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"],"mappings":"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"}���������������������������������������������������������������������������������������lib/plugins/flow/index.js���������������������������������������������������������������������������0000644�����������������00000250747�15120211212�0011411 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;
var _types = require("../../tokenizer/types");
var _context = require("../../tokenizer/context");
var _identifier = require("../../util/identifier");
var _scope = require("./scope");
var _scopeflags = require("../../util/scopeflags");
var _parseError = require("../../parse-error");
var _node = require("../../parser/node");
const reservedTypes = new Set(["_", "any", "bool", "boolean", "empty", "extends", "false", "interface", "mixed", "null", "number", "static", "string", "true", "typeof", "void"]);
const FlowErrors = (0, _parseError.ParseErrorEnum)`flow`({
  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: ({
    reservedType
  }) => `Cannot overwrite reserved type ${reservedType}.`,
  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: ({
    memberName,
    enumName
  }) => `Boolean enum members need to be initialized. Use either \`${memberName} = true,\` or \`${memberName} = false,\` in enum \`${enumName}\`.`,
  EnumDuplicateMemberName: ({
    memberName,
    enumName
  }) => `Enum member names need to be unique, but the name \`${memberName}\` has already been used before in enum \`${enumName}\`.`,
  EnumInconsistentMemberValues: ({
    enumName
  }) => `Enum \`${enumName}\` has inconsistent member initializers. Either use no initializers, or consistently use literals (either booleans, numbers, or strings) for all member initializers.`,
  EnumInvalidExplicitType: ({
    invalidEnumType,
    enumName
  }) => `Enum type \`${invalidEnumType}\` is not valid. Use one of \`boolean\`, \`number\`, \`string\`, or \`symbol\` in enum \`${enumName}\`.`,
  EnumInvalidExplicitTypeUnknownSupplied: ({
    enumName
  }) => `Supplied enum type is not valid. Use one of \`boolean\`, \`number\`, \`string\`, or \`symbol\` in enum \`${enumName}\`.`,
  EnumInvalidMemberInitializerPrimaryType: ({
    enumName,
    memberName,
    explicitType
  }) => `Enum \`${enumName}\` has type \`${explicitType}\`, so the initializer of \`${memberName}\` needs to be a ${explicitType} literal.`,
  EnumInvalidMemberInitializerSymbolType: ({
    enumName,
    memberName
  }) => `Symbol enum members cannot be initialized. Use \`${memberName},\` in enum \`${enumName}\`.`,
  EnumInvalidMemberInitializerUnknownType: ({
    enumName,
    memberName
  }) => `The enum member initializer for \`${memberName}\` needs to be a literal (either a boolean, number, or string) in enum \`${enumName}\`.`,
  EnumInvalidMemberName: ({
    enumName,
    memberName,
    suggestion
  }) => `Enum member names cannot start with lowercase 'a' through 'z'. Instead of using \`${memberName}\`, consider using \`${suggestion}\`, in enum \`${enumName}\`.`,
  EnumNumberMemberNotInitialized: ({
    enumName,
    memberName
  }) => `Number enum members need to be initialized, e.g. \`${memberName} = 1\` in enum \`${enumName}\`.`,
  EnumStringMemberInconsistentlyInitailized: ({
    enumName
  }) => `String enum members need to consistently either all use initializers, or use no initializers, in enum \`${enumName}\`.`,
  GetterMayNotHaveThisParam: "A getter cannot have a `this` parameter.",
  ImportReflectionHasImportType: "An `import module` declaration can not use `type` or `typeof` keyword.",
  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: Object.assign({
    message: "A binding pattern parameter cannot be optional in an implementation signature."
  }, {
    reasonCode: "OptionalBindingPattern"
  }),
  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: ({
    reservedType
  }) => `Unexpected reserved type ${reservedType}.`,
  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 `<T> async () => {}`, use `async <T>() => {}`.",
  UnsupportedDeclareExportKind: ({
    unsupportedExportKind,
    suggestion
  }) => `\`declare export ${unsupportedExportKind}\` is not supported. Use \`${suggestion}\` instead.`,
  UnsupportedStatementInDeclareModule: "Only declares and type imports are allowed inside declare module.",
  UnterminatedFlowComment: "Unterminated flow-comment."
});
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";
}
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 _default = superClass => class FlowParserMixin extends superClass {
  constructor(...args) {
    super(...args);
    this.flowPragma = undefined;
  }
  getScopeHandler() {
    return _scope.default;
  }
  shouldParseTypes() {
    return this.getPluginOption("flow", "all") || this.flowPragma === "flow";
  }
  shouldParseEnums() {
    return !!this.getPluginOption("flow", "enums");
  }
  finishToken(type, val) {
    if (type !== 131 && type !== 13 && type !== 28) {
      if (this.flowPragma === undefined) {
        this.flowPragma = null;
      }
    }
    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");
      }
    }
    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(108);
    if (this.state.lastTokStart > moduloLoc.index + 1) {
      this.raise(FlowErrors.UnexpectedSpaceBetweenModuloChecks, {
        at: moduloLoc
      });
    }
    if (this.eat(10)) {
      node.value = super.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, _scopeflags.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(125)) {
      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(128)) {
      return this.flowParseDeclareTypeAlias(node);
    } else if (this.isContextual(129)) {
      return this.flowParseDeclareOpaqueType(node);
    } else if (this.isContextual(127)) {
      return this.flowParseDeclareInterface(node);
    } else if (this.match(82)) {
      return this.flowParseDeclareExportDeclaration(node, insideModule);
    } else {
      this.unexpected();
    }
  }
  flowParseDeclareVariable(node) {
    this.next();
    node.id = this.flowParseTypeAnnotatableIdentifier(true);
    this.scope.declareName(node.id.name, _scopeflags.BIND_VAR, node.id.loc.start);
    this.semicolon();
    return this.finishNode(node, "DeclareVariable");
  }
  flowParseDeclareModule(node) {
    this.scope.enter(_scopeflags.SCOPE_OTHER);
    if (this.match(131)) {
      node.id = super.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(128) && !this.match(87)) {
          this.raise(FlowErrors.InvalidNonTypeImportInDeclareModule, {
            at: this.state.lastTokStartLoc
          });
        }
        super.parseImport(bodyNode);
      } else {
        this.expectContextual(123, 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, {
            at: bodyElement
          });
        }
        kind = "ES";
      } else if (bodyElement.type === "DeclareModuleExports") {
        if (hasModuleExport) {
          this.raise(FlowErrors.DuplicateDeclareModuleExports, {
            at: bodyElement
          });
        }
        if (kind === "ES") {
          this.raise(FlowErrors.AmbiguousDeclareModuleKind, {
            at: 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(128) || this.isContextual(127)) && !insideModule) {
        const label = this.state.value;
        throw this.raise(FlowErrors.UnsupportedDeclareExportKind, {
          at: this.state.startLoc,
          unsupportedExportKind: label,
          suggestion: exportSuggestions[label]
        });
      }
      if (this.match(74) || this.match(68) || this.match(80) || this.isContextual(129)) {
        node.declaration = this.flowParseDeclare(this.startNode());
        node.default = false;
        return this.finishNode(node, "DeclareExportDeclaration");
      } else if (this.match(55) || this.match(5) || this.isContextual(127) || this.isContextual(128) || this.isContextual(129)) {
        node = this.parseExport(node, null);
        if (node.type === "ExportNamedDeclaration") {
          node.type = "ExportDeclaration";
          node.default = false;
          delete node.exportKind;
        }
        node.type = "Declare" + node.type;
        return node;
      }
    }
    this.unexpected();
  }
  flowParseDeclareModuleExports(node) {
    this.next();
    this.expectContextual(109);
    node.typeAnnotation = this.flowParseTypeAnnotation();
    this.semicolon();
    return this.finishNode(node, "DeclareModuleExports");
  }
  flowParseDeclareTypeAlias(node) {
    this.next();
    const finished = this.flowParseTypeAlias(node);
    finished.type = "DeclareTypeAlias";
    return finished;
  }
  flowParseDeclareOpaqueType(node) {
    this.next();
    const finished = this.flowParseOpaqueType(node, true);
    finished.type = "DeclareOpaqueType";
    return finished;
  }
  flowParseDeclareInterface(node) {
    this.next();
    this.flowParseInterfaceish(node, false);
    return this.finishNode(node, "DeclareInterface");
  }
  flowParseInterfaceish(node, isClass) {
    node.id = this.flowParseRestrictedIdentifier(!isClass, true);
    this.scope.declareName(node.id.name, isClass ? _scopeflags.BIND_FUNCTION : _scopeflags.BIND_LEXICAL, node.id.loc.start);
    if (this.match(47)) {
      node.typeParameters = this.flowParseTypeParameterDeclaration();
    } else {
      node.typeParameters = null;
    }
    node.extends = [];
    if (this.eat(81)) {
      do {
        node.extends.push(this.flowParseInterfaceExtends());
      } while (!isClass && this.eat(12));
    }
    if (isClass) {
      node.implements = [];
      node.mixins = [];
      if (this.eatContextual(115)) {
        do {
          node.mixins.push(this.flowParseInterfaceExtends());
        } while (this.eat(12));
      }
      if (this.eatContextual(111)) {
        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, false);
    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,
      reservedType: 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, _scopeflags.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(128);
    node.id = this.flowParseRestrictedIdentifier(true, true);
    this.scope.declareName(node.id.name, _scopeflags.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(140)) {
      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(127);
    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(132) || this.match(131) ? super.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.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(116)) {
        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 ((0, _types.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, {
            at: 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, {
          at: 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.loc.start));
        if (kind === "get" || kind === "set") {
          this.flowCheckGetterSetterParams(node);
        }
        if (!allowSpread && node.key.name === "constructor" && node.value.this) {
          this.raise(FlowErrors.ThisParamBannedInConstructor, {
            at: 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, {
        at: property.value.this
      });
    }
    if (length !== paramCount) {
      this.raise(property.kind === "get" ? _parseError.Errors.BadGetterArity : _parseError.Errors.BadSetterArity, {
        at: property
      });
    }
    if (property.kind === "set" && property.value.rest) {
      this.raise(_parseError.Errors.BadSetterRestParameter, {
        at: property
      });
    }
  }
  flowObjectTypeSemicolon() {
    if (!this.eat(13) && !this.eat(12) && !this.match(8) && !this.match(9)) {
      this.unexpected();
    }
  }
  flowParseQualifiedTypeIdentifier(startLoc, id) {
    var _startLoc;
    (_startLoc = startLoc) != null ? _startLoc : startLoc = this.state.startLoc;
    let node = id || this.flowParseRestrictedIdentifier(true);
    while (this.eat(16)) {
      const node2 = this.startNodeAt(startLoc);
      node2.qualification = node;
      node2.id = this.flowParseRestrictedIdentifier(true);
      node = this.finishNode(node2, "QualifiedTypeIdentifier");
    }
    return node;
  }
  flowParseGenericType(startLoc, id) {
    const node = this.startNodeAt(startLoc);
    node.typeParameters = null;
    node.id = this.flowParseQualifiedTypeIdentifier(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, {
          at: node
        });
      }
      name = this.parseIdentifier(isThis);
      if (this.eat(17)) {
        optional = true;
        if (isThis) {
          this.raise(FlowErrors.ThisParamMayNotBeOptional, {
            at: 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.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(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(startLoc, id);
    }
  }
  flowParsePrimaryType() {
    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 ((0, _types.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 131:
        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(132)) {
            return this.parseLiteralAtNode(-this.state.value, "NumberLiteralTypeAnnotation", node);
          }
          if (this.match(133)) {
            return this.parseLiteralAtNode(-this.state.value, "BigIntLiteralTypeAnnotation", node);
          }
          throw this.raise(FlowErrors.UnexpectedSubtractionOperand, {
            at: this.state.startLoc
          });
        }
        this.unexpected();
        return;
      case 132:
        return this.parseLiteral(this.state.value, "NumberLiteralTypeAnnotation");
      case 133:
        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 ((0, _types.tokenIsKeyword)(this.state.type)) {
          const label = (0, _types.tokenLabelName)(this.state.type);
          this.next();
          return super.createIdentifier(node, label);
        } else if ((0, _types.tokenIsIdentifier)(this.state.type)) {
          if (this.isContextual(127)) {
            return this.flowParseInterfaceType();
          }
          return this.flowIdentToTypeAnnotation(startLoc, node, this.parseIdentifier());
        }
    }
    this.unexpected();
  }
  flowParsePostfixType() {
    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(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.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 === 130 && this.state.value === "_") {
      const startLoc = this.state.startLoc;
      const node = this.parseIdentifier();
      return this.flowParseGenericType(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();
      return this.finishNode(variance, "Variance");
    }
    return variance;
  }
  parseFunctionBody(node, allowExpressionBody, isMethod = false) {
    if (allowExpressionBody) {
      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;
    }
    return super.parseFunctionBodyAndFinish(node, type, isMethod);
  }
  parseStatementLike(flags) {
    if (this.state.strict && this.isContextual(127)) {
      const lookahead = this.lookahead();
      if ((0, _types.tokenIsKeywordOrIdentifier)(lookahead.type)) {
        const node = this.startNode();
        this.next();
        return this.flowParseInterface(node);
      }
    } else if (this.shouldParseEnums() && this.isContextual(124)) {
      const node = this.startNode();
      this.next();
      return this.flowParseEnumDeclaration(node);
    }
    const stmt = super.parseStatementLike(flags);
    if (this.flowPragma === undefined && !this.isValidDirective(stmt)) {
      this.flowPragma = null;
    }
    return stmt;
  }
  parseExpressionStatement(node, expr, decorators) {
    if (expr.type === "Identifier") {
      if (expr.name === "declare") {
        if (this.match(80) || (0, _types.tokenIsIdentifier)(this.state.type) || this.match(68) || this.match(74) || this.match(82)) {
          return this.flowParseDeclare(node);
        }
      } else if ((0, _types.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, decorators);
  }
  shouldParseExportDeclaration() {
    const {
      type
    } = this.state;
    if ((0, _types.tokenIsFlowInterfaceOrTypeOrOpaque)(type) || this.shouldParseEnums() && type === 124) {
      return !this.state.containsEsc;
    }
    return super.shouldParseExportDeclaration();
  }
  isExportDefaultSpecifier() {
    const {
      type
    } = this.state;
    if ((0, _types.tokenIsFlowInterfaceOrTypeOrOpaque)(type) || this.shouldParseEnums() && type === 124) {
      return this.state.containsEsc;
    }
    return super.isExportDefaultSpecifier();
  }
  parseExportDefaultExpression() {
    if (this.shouldParseEnums() && this.isContextual(124)) {
      const node = this.startNode();
      this.next();
      return this.flowParseEnumDeclaration(node);
    }
    return super.parseExportDefaultExpression();
  }
  parseConditional(expr, 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(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(_scopeflags.SCOPE_FUNCTION | _scopeflags.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, startLoc) {
    node = super.parseParenItem(node, startLoc);
    if (this.eat(17)) {
      node.optional = true;
      this.resetEndLocation(node);
    }
    if (this.match(14)) {
      const typeCastNode = this.startNodeAt(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);
  }
  parseExportDeclaration(node) {
    if (this.isContextual(128)) {
      node.exportKind = "type";
      const declarationNode = this.startNode();
      this.next();
      if (this.match(5)) {
        node.specifiers = this.parseExportSpecifiers(true);
        super.parseExportFrom(node);
        return null;
      } else {
        return this.flowParseTypeAlias(declarationNode);
      }
    } else if (this.isContextual(129)) {
      node.exportKind = "type";
      const declarationNode = this.startNode();
      this.next();
      return this.flowParseOpaqueType(declarationNode, false);
    } else if (this.isContextual(127)) {
      node.exportKind = "type";
      const declarationNode = this.startNode();
      this.next();
      return this.flowParseInterface(declarationNode);
    } else if (this.shouldParseEnums() && this.isContextual(124)) {
      node.exportKind = "value";
      const declarationNode = this.startNode();
      this.next();
      return this.flowParseEnumDeclaration(declarationNode);
    } else {
      return super.parseExportDeclaration(node);
    }
  }
  eatExportStar(node) {
    if (super.eatExportStar(node)) return true;
    if (this.isContextual(128) && 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(123)) {
      if (super.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, {
          at: 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(_parseError.Errors.InvalidIdentifier, {
        at: this.state.curPosition(),
        identifierName: fullWord
      });
    }
    this.finishToken(130, fullWord);
  }
  getTokenFromCode(code) {
    const next = this.input.charCodeAt(this.state.pos + 1);
    if (code === 123 && next === 124) {
      this.finishOp(6, 2);
    } else if (this.state.inType && (code === 62 || code === 60)) {
      this.finishOp(code === 62 ? 48 : 47, 1);
    } else if (this.state.inType && code === 63) {
      if (next === 46) {
        this.finishOp(18, 2);
      } else {
        this.finishOp(17, 1);
      }
    } else if ((0, _identifier.isIteratorStart)(code, next, this.input.charCodeAt(this.state.pos + 2))) {
      this.state.pos += 2;
      this.readIterator();
    } else {
      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 (!isLHS && node.type === "AssignmentExpression" && node.left.type === "TypeCastExpression") {
      node.left = this.typeCastToParameter(node.left);
    }
    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);
      }
    }
    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, {
          at: 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;
  }
  isValidLVal(type, isParenthesized, binding) {
    return type === "TypeCastExpression" || super.isValidLVal(type, isParenthesized, binding);
  }
  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, {
          at: 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, {
          at: 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(111)) {
      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, {
          at: param
        });
      } else if (this.isThisParam(param)) {
        this.raise(FlowErrors.SetterMayNotHaveThisParam, {
          at: param
        });
      }
    }
  }
  parsePropertyNamePrefixOperator(node) {
    node.variance = this.flowParseVariance();
  }
  parseObjPropValue(prop, 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();
    }
    const result = super.parseObjPropValue(prop, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors);
    if (typeParameters) {
      (result.value || result).typeParameters = typeParameters;
    }
    return result;
  }
  parseAssignableListItemTypes(param) {
    if (this.eat(17)) {
      if (param.type !== "Identifier") {
        this.raise(FlowErrors.PatternIsOptional, {
          at: param
        });
      }
      if (this.isThisParam(param)) {
        this.raise(FlowErrors.ThisParamMayNotBeOptional, {
          at: param
        });
      }
      param.optional = true;
    }
    if (this.match(14)) {
      param.typeAnnotation = this.flowParseTypeAnnotation();
    } else if (this.isThisParam(param)) {
      this.raise(FlowErrors.ThisParamAnnotationRequired, {
        at: param
      });
    }
    if (this.match(29) && this.isThisParam(param)) {
      this.raise(FlowErrors.ThisParamNoDefault, {
        at: param
      });
    }
    this.resetEndLocation(param);
    return param;
  }
  parseMaybeDefault(startLoc, left) {
    const node = super.parseMaybeDefault(startLoc, left);
    if (node.type === "AssignmentPattern" && node.typeAnnotation && node.right.start < node.typeAnnotation.start) {
      this.raise(FlowErrors.TypeBeforeInitializer, {
        at: node.typeAnnotation
      });
    }
    return node;
  }
  checkImportReflection(node) {
    super.checkImportReflection(node);
    if (node.module && node.importKind !== "value") {
      this.raise(FlowErrors.ImportReflectionHasImportType, {
        at: node.specifiers[0].loc.start
      });
    }
  }
  parseImportSpecifierLocal(node, specifier, type) {
    specifier.local = hasTypeImportKind(node) ? this.flowParseRestrictedIdentifier(true, true) : this.parseIdentifier();
    node.specifiers.push(this.finishImportSpecifier(specifier, type));
  }
  isPotentialImportPhase(isExport) {
    if (super.isPotentialImportPhase(isExport)) return true;
    if (this.isContextual(128)) {
      if (!isExport) return true;
      const ch = this.lookaheadCharCode();
      return ch === 123 || ch === 42;
    }
    return !isExport && this.isContextual(87);
  }
  applyImportPhase(node, isExport, phase, loc) {
    super.applyImportPhase(node, isExport, phase, loc);
    if (isExport) {
      if (!phase && this.match(65)) {
        return;
      }
      node.exportKind = phase === "type" ? phase : "value";
    } else {
      if (phase === "type" && this.match(55)) this.unexpected();
      node.importKind = phase === "type" || phase === "typeof" ? phase : "value";
    }
  }
  parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, bindingType) {
    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 && !(0, _types.tokenIsKeywordOrIdentifier)(this.state.type)) {
        specifier.imported = as_ident;
        specifier.importKind = specifierTypeKind;
        specifier.local = (0, _node.cloneIdentifier)(as_ident);
      } else {
        specifier.imported = firstIdent;
        specifier.importKind = null;
        specifier.local = this.parseIdentifier();
      }
    } else {
      if (specifierTypeKind !== null && (0, _types.tokenIsKeywordOrIdentifier)(this.state.type)) {
        specifier.imported = this.parseIdentifier(true);
        specifier.importKind = specifierTypeKind;
      } else {
        if (importedIsString) {
          throw this.raise(_parseError.Errors.ImportBindingIsString, {
            at: specifier,
            importName: firstIdent.value
          });
        }
        specifier.imported = firstIdent;
        specifier.importKind = null;
      }
      if (this.eatContextual(93)) {
        specifier.local = this.parseIdentifier();
      } else {
        isBinding = true;
        specifier.local = (0, _node.cloneIdentifier)(specifier.imported);
      }
    }
    const specifierIsTypeImport = hasTypeImportKind(specifier);
    if (isInTypeOnlyImport && specifierIsTypeImport) {
      this.raise(FlowErrors.ImportTypeShorthandOnlyInPureImport, {
        at: 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);
    }
    return this.finishImportSpecifier(specifier, "ImportSpecifier");
  }
  parseBindingAtom() {
    switch (this.state.type) {
      case 78:
        return this.parseIdentifier(true);
      default:
        return super.parseBindingAtom();
    }
  }
  parseFunctionParams(node, isConstructor) {
    const kind = node.kind;
    if (kind !== "get" && kind !== "set" && this.match(47)) {
      node.typeParameters = this.flowParseTypeParameterDeclaration();
    }
    super.parseFunctionParams(node, isConstructor);
  }
  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(140) || 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 === _context.types.j_oTag || currentContext === _context.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, {
              at: 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, {
        at: 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, strictModeChanged = true) {
    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, {
          at: node.params[i]
        });
      }
    }
    super.checkParams(node, allowDuplicates, isArrowFunction, strictModeChanged);
  }
  parseParenAndDistinguishExpression(canBeArrow) {
    return super.parseParenAndDistinguishExpression(canBeArrow && this.state.noArrowAt.indexOf(this.state.start) === -1);
  }
  parseSubscripts(base, startLoc, noCalls) {
    if (base.type === "Identifier" && base.name === "async" && this.state.noArrowAt.indexOf(startLoc.index) !== -1) {
      this.next();
      const node = this.startNodeAt(startLoc);
      node.callee = base;
      node.arguments = super.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(startLoc) || abort(), state);
      if (!arrow.error && !arrow.aborted) return arrow.node;
      const result = this.tryParse(() => super.parseSubscripts(base, 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, startLoc, noCalls);
  }
  parseSubscript(base, 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(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(startLoc);
      node.callee = base;
      const result = this.tryParse(() => {
        node.typeArguments = this.flowParseTypeParameterInstantiationCallOrNew();
        this.expect(10);
        node.arguments = super.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, startLoc, noCalls, subscriptState);
  }
  parseNewCallee(node) {
    super.parseNewCallee(node);
    let targs = null;
    if (this.shouldParseTypes() && this.match(47)) {
      targs = this.tryParse(() => this.flowParseTypeParameterInstantiationCallOrNew()).node;
    }
    node.typeArguments = targs;
  }
  parseAsyncArrowWithTypeParameters(startLoc) {
    const node = this.startNodeAt(startLoc);
    this.parseFunctionParams(node, false);
    if (!this.parseArrow(node)) return;
    return super.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();
      const commentSkip = this.skipFlowComment();
      if (commentSkip) {
        this.state.pos += commentSkip;
        this.state.hasFlowComment = true;
      }
      return;
    }
    return super.skipBlockComment(this.state.hasFlowComment ? "*-/" : "*/");
  }
  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(_parseError.Errors.UnterminatedComment, {
        at: this.state.curPosition()
      });
    }
  }
  flowEnumErrorBooleanMemberNotInitialized(loc, {
    enumName,
    memberName
  }) {
    this.raise(FlowErrors.EnumBooleanMemberNotInitialized, {
      at: loc,
      memberName,
      enumName
    });
  }
  flowEnumErrorInvalidMemberInitializer(loc, enumContext) {
    return this.raise(!enumContext.explicitType ? FlowErrors.EnumInvalidMemberInitializerUnknownType : enumContext.explicitType === "symbol" ? FlowErrors.EnumInvalidMemberInitializerSymbolType : FlowErrors.EnumInvalidMemberInitializerPrimaryType, Object.assign({
      at: loc
    }, enumContext));
  }
  flowEnumErrorNumberMemberNotInitialized(loc, {
    enumName,
    memberName
  }) {
    this.raise(FlowErrors.EnumNumberMemberNotInitialized, {
      at: loc,
      enumName,
      memberName
    });
  }
  flowEnumErrorStringMemberInconsistentlyInitailized(node, {
    enumName
  }) {
    this.raise(FlowErrors.EnumStringMemberInconsistentlyInitailized, {
      at: node,
      enumName
    });
  }
  flowEnumMemberInit() {
    const startLoc = this.state.startLoc;
    const endOfInit = () => this.match(12) || this.match(8);
    switch (this.state.type) {
      case 132:
        {
          const literal = this.parseNumericLiteral(this.state.value);
          if (endOfInit()) {
            return {
              type: "number",
              loc: literal.loc.start,
              value: literal
            };
          }
          return {
            type: "invalid",
            loc: startLoc
          };
        }
      case 131:
        {
          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, {
          at: id,
          memberName,
          suggestion: memberName[0].toUpperCase() + memberName.slice(1),
          enumName
        });
      }
      if (seenNames.has(memberName)) {
        this.raise(FlowErrors.EnumDuplicateMemberName, {
          at: 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)) return null;
    if (!(0, _types.tokenIsIdentifier)(this.state.type)) {
      throw this.raise(FlowErrors.EnumInvalidExplicitTypeUnknownSupplied, {
        at: this.state.startLoc,
        enumName
      });
    }
    const {
      value
    } = this.state;
    this.next();
    if (value !== "boolean" && value !== "number" && value !== "string" && value !== "symbol") {
      this.raise(FlowErrors.EnumInvalidExplicitType, {
        at: this.state.startLoc,
        enumName,
        invalidEnumType: value
      });
    }
    return value;
  }
  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;
  }
};
exports.default = _default;

//# sourceMappingURL=index.js.map
�������������������������lib/plugins/flow/index.js.map�����������������������������������������������������������������������0000644�����������������00000663724�15120211212�0012170 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������{"version":3,"names":["_types","require","_context","_identifier","_scope","_scopeflags","_parseError","_node","reservedTypes","Set","FlowErrors","ParseErrorEnum","AmbiguousConditionalArrow","AmbiguousDeclareModuleKind","AssignReservedType","reservedType","DeclareClassElement","DeclareClassFieldInitializer","DuplicateDeclareModuleExports","EnumBooleanMemberNotInitialized","memberName","enumName","EnumDuplicateMemberName","EnumInconsistentMemberValues","EnumInvalidExplicitType","invalidEnumType","EnumInvalidExplicitTypeUnknownSupplied","EnumInvalidMemberInitializerPrimaryType","explicitType","EnumInvalidMemberInitializerSymbolType","EnumInvalidMemberInitializerUnknownType","EnumInvalidMemberName","suggestion","EnumNumberMemberNotInitialized","EnumStringMemberInconsistentlyInitailized","GetterMayNotHaveThisParam","ImportReflectionHasImportType","ImportTypeShorthandOnlyInPureImport","InexactInsideExact","InexactInsideNonObject","InexactVariance","InvalidNonTypeImportInDeclareModule","MissingTypeParamDefault","NestedDeclareModule","NestedFlowComment","PatternIsOptional","Object","assign","message","reasonCode","SetterMayNotHaveThisParam","SpreadVariance","ThisParamAnnotationRequired","ThisParamBannedInConstructor","ThisParamMayNotBeOptional","ThisParamMustBeFirst","ThisParamNoDefault","TypeBeforeInitializer","TypeCastInPattern","UnexpectedExplicitInexactInObject","UnexpectedReservedType","UnexpectedReservedUnderscore","UnexpectedSpaceBetweenModuloChecks","UnexpectedSpreadType","UnexpectedSubtractionOperand","UnexpectedTokenAfterTypeParameter","UnexpectedTypeParameterBeforeAsyncArrowFunction","UnsupportedDeclareExportKind","unsupportedExportKind","UnsupportedStatementInDeclareModule","UnterminatedFlowComment","isEsModuleType","bodyElement","type","declaration","hasTypeImportKind","node","importKind","exportSuggestions","const","let","interface","partition","list","test","list1","list2","i","length","push","FLOW_PRAGMA_REGEX","_default","superClass","FlowParserMixin","constructor","args","flowPragma","undefined","getScopeHandler","FlowScopeHandler","shouldParseTypes","getPluginOption","shouldParseEnums","finishToken","val","addComment","comment","matches","exec","value","Error","flowParseTypeInitialiser","tok","oldInType","state","inType","expect","flowParseType","flowParsePredicate","startNode","moduloLoc","startLoc","next","expectContextual","lastTokStart","index","raise","at","eat","parseExpression","finishNode","flowParseTypeAndPredicateInitialiser","predicate","match","flowParseDeclareClass","flowParseInterfaceish","flowParseDeclareFunction","id","parseIdentifier","typeNode","typeContainer","typeParameters","flowParseTypeParameterDeclaration","tmp","flowParseFunctionTypeParams","params","rest","this","_this","returnType","typeAnnotation","resetEndLocation","semicolon","scope","declareName","name","BIND_FLOW_DECLARE_FN","loc","start","flowParseDeclare","insideModule","flowParseDeclareVariable","eatContextual","flowParseDeclareModuleExports","lastTokStartLoc","flowParseDeclareModule","isContextual","flowParseDeclareTypeAlias","flowParseDeclareOpaqueType","flowParseDeclareInterface","flowParseDeclareExportDeclaration","unexpected","flowParseTypeAnnotatableIdentifier","BIND_VAR","enter","SCOPE_OTHER","parseExprAtom","bodyNode","body","parseImport","exit","kind","hasModuleExport","forEach","default","isLet","label","parseExport","exportKind","flowParseTypeAnnotation","finished","flowParseTypeAlias","flowParseOpaqueType","isClass","flowParseRestrictedIdentifier","BIND_FUNCTION","BIND_LEXICAL","extends","flowParseInterfaceExtends","implements","mixins","flowParseObjectType","allowStatic","allowExact","allowSpread","allowProto","allowInexact","flowParseQualifiedTypeIdentifier","flowParseTypeParameterInstantiation","flowParseInterface","checkNotUnderscore","word","checkReservedType","has","liberal","right","declare","supertype","impltype","flowParseTypeParameter","requireDefault","nodeStartLoc","variance","flowParseVariance","ident","bound","defaultRequired","typeParameter","oldNoAnonFunctionType","noAnonFunctionType","flowParseTypeParameterInstantiationCallOrNew","flowParseTypeOrImplicitInstantiation","flowParseInterfaceType","flowParseObjectPropertyKey","flowParseObjectTypeIndexer","isStatic","static","lookahead","key","flowParseObjectTypeInternalSlot","method","optional","flowParseObjectTypeMethodish","startNodeAt","flowParseFunctionTypeParam","flowParseObjectTypeCallProperty","valueNode","nodeStart","callProperties","properties","indexers","internalSlots","endDelim","exact","inexact","protoStartLoc","inexactStartLoc","tokenIsLiteralPropertyName","propOrInexact","flowParseObjectTypeProperty","flowObjectTypeSemicolon","out","isInexactToken","argument","proto","flowCheckGetterSetterParams","property","paramCount","Errors","BadGetterArity","BadSetterArity","BadSetterRestParameter","_startLoc","node2","qualification","flowParseGenericType","flowParseTypeofType","flowParsePrimaryType","flowParseTupleType","types","pos","first","lh","isThis","reinterpretTypeAsFunctionTypeParam","flowIdentToTypeAnnotation","isGroupedType","tokenIsIdentifier","token","parseLiteral","parseLiteralAtNode","tokenIsKeyword","tokenLabelName","createIdentifier","flowParsePostfixType","seenOptionalIndexedAccess","canInsertSemicolon","elementType","objectType","indexType","flowParsePrefixType","flowParseAnonFunctionWithoutParens","param","flowParseIntersectionType","flowParseUnionType","allowPrimitiveOverride","typeCastToParameter","expression","end","parseFunctionBody","allowExpressionBody","isMethod","forwardNoArrowParamsConversionAt","parseFunctionBodyAndFinish","parseStatementLike","flags","strict","tokenIsKeywordOrIdentifier","flowParseEnumDeclaration","stmt","isValidDirective","parseExpressionStatement","expr","decorators","shouldParseExportDeclaration","tokenIsFlowInterfaceOrTypeOrOpaque","containsEsc","isExportDefaultSpecifier","parseExportDefaultExpression","parseConditional","refExpressionErrors","maybeInArrowParameters","nextCh","lookaheadCharCode","setOptionalParametersError","clone","originalNoArrowAt","noArrowAt","consequent","failed","tryParseConditionalConsequent","valid","invalid","getArrowLikeExpressions","alternate","parseMaybeAssign","noArrowParamsConversionAt","parseMaybeAssignAllowIn","pop","disallowInvalid","stack","arrows","finishArrowValidation","every","isAssignable","_node$extra","toAssignableList","extra","trailingCommaLoc","SCOPE_FUNCTION","SCOPE_ARROW","checkParams","parse","result","indexOf","parseParenItem","typeCastNode","assertModuleNodeAllowed","parseExportDeclaration","declarationNode","specifiers","parseExportSpecifiers","parseExportFrom","eatExportStar","maybeParseExportNamespaceSpecifier","hasNamespace","parseClassId","isStatement","optionalId","parseClassMember","classBody","member","parseClassMemberFromModifier","isIterator","readIterator","readWord1","fullWord","InvalidIdentifier","curPosition","identifierName","getTokenFromCode","code","input","charCodeAt","finishOp","isIteratorStart","isBinding","toAssignable","isLHS","left","exprList","toReferencedList","isParenthesizedExpr","_expr$extra","parenthesized","parseArrayLike","close","canBePattern","isTuple","elements","isValidLVal","isParenthesized","binding","parseClassProperty","parseClassPrivateProperty","isClassMethod","isClassProperty","isNonstaticConstructor","pushClassMethod","isGenerator","isAsync","isConstructor","allowsDirectSuper","isThisParam","pushClassPrivateMethod","parseClassSuper","superTypeParameters","implemented","checkGetterSetterParams","getObjectOrClassMethodParams","parsePropertyNamePrefixOperator","parseObjPropValue","prop","isPattern","isAccessor","parseAssignableListItemTypes","parseMaybeDefault","checkImportReflection","module","parseImportSpecifierLocal","specifier","local","finishImportSpecifier","isPotentialImportPhase","isExport","ch","applyImportPhase","phase","parseImportSpecifier","importedIsString","isInTypeOnlyImport","isMaybeTypeOnly","bindingType","firstIdent","imported","specifierTypeKind","isLookaheadContextual","as_ident","cloneIdentifier","ImportBindingIsString","importName","specifierIsTypeImport","checkReservedWord","parseBindingAtom","parseFunctionParams","parseVarId","decl","parseAsyncArrowFromCallExpression","call","shouldParseAsyncArrow","afterLeftParse","_jsx","jsx","hasPlugin","tryParse","error","context","currentContext","tc","j_oTag","j_expr","_jsx2","_jsx3","arrow","abort","_arrowExpression$extr","arrowExpression","resetStartLocationFromNode","maybeUnwrapTypeCastExpression","aborted","async","failState","thrown","parseArrow","shouldParseArrow","setArrowFunctionParameters","allowDuplicates","isArrowFunction","strictModeChanged","parseParenAndDistinguishExpression","canBeArrow","parseSubscripts","base","noCalls","callee","arguments","parseCallExpressionArguments","parseAsyncArrowWithTypeParameters","parseSubscript","subscriptState","isLookaheadToken_lt","optionalChainMember","stop","typeArguments","finishCallExpression","parseNewCallee","targs","parseArrowExpression","readToken_mult_modulo","hasFlowComment","nextToken","readToken_pipe_amp","parseTopLevel","file","program","fileNode","skipBlockComment","skipFlowComment","hasFlowCommentCompletion","commentSkip","shiftToFirstNonWhiteSpace","includes","ch2","ch3","slice","UnterminatedComment","flowEnumErrorBooleanMemberNotInitialized","flowEnumErrorInvalidMemberInitializer","enumContext","flowEnumErrorNumberMemberNotInitialized","flowEnumErrorStringMemberInconsistentlyInitailized","flowEnumMemberInit","endOfInit","literal","parseNumericLiteral","parseStringLiteral","parseBooleanLiteral","flowEnumMemberRaw","init","flowEnumCheckExplicitTypeMismatch","expectedType","flowEnumMembers","seenNames","members","booleanMembers","numberMembers","stringMembers","defaultedMembers","hasUnknownMembers","memberNode","toUpperCase","add","flowEnumStringMembers","initializedMembers","flowEnumParseExplicitType","flowEnumBody","nameLoc","empty","boolsLen","numsLen","strsLen","defaultedLen","nextTokenStart","afterNext","exports"],"sources":["../../../src/plugins/flow/index.ts"],"sourcesContent":["/*:: declare var invariant; */\n\nimport type Parser from \"../../parser\";\nimport {\n  tokenIsIdentifier,\n  tokenIsKeyword,\n  tokenIsKeywordOrIdentifier,\n  tokenIsLiteralPropertyName,\n  tokenLabelName,\n  tt,\n  type TokenType,\n  tokenIsFlowInterfaceOrTypeOrOpaque,\n} from \"../../tokenizer/types\";\nimport type * as N from \"../../types\";\nimport type { Position } from \"../../util/location\";\nimport { types as tc } from \"../../tokenizer/context\";\nimport * as charCodes from \"charcodes\";\nimport { isIteratorStart } from \"../../util/identifier\";\nimport FlowScopeHandler from \"./scope\";\nimport {\n  BIND_LEXICAL,\n  BIND_VAR,\n  BIND_FUNCTION,\n  BIND_FLOW_DECLARE_FN,\n  SCOPE_ARROW,\n  SCOPE_FUNCTION,\n  SCOPE_OTHER,\n  type BindingTypes,\n} from \"../../util/scopeflags\";\nimport type { ExpressionErrors } from \"../../parser/util\";\nimport type { ParseStatementFlag } from \"../../parser/statement\";\nimport { Errors, ParseErrorEnum } from \"../../parse-error\";\nimport { cloneIdentifier, type Undone } from \"../../parser/node\";\n\nconst reservedTypes = new Set([\n  \"_\",\n  \"any\",\n  \"bool\",\n  \"boolean\",\n  \"empty\",\n  \"extends\",\n  \"false\",\n  \"interface\",\n  \"mixed\",\n  \"null\",\n  \"number\",\n  \"static\",\n  \"string\",\n  \"true\",\n  \"typeof\",\n  \"void\",\n]);\n\n/* eslint sort-keys: \"error\" */\n// The Errors key follows https://github.com/facebook/flow/blob/master/src/parser/parse_error.ml unless it does not exist\nconst FlowErrors = ParseErrorEnum`flow`({\n  AmbiguousConditionalArrow:\n    \"Ambiguous expression: wrap the arrow functions in parentheses to disambiguate.\",\n  AmbiguousDeclareModuleKind:\n    \"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.\",\n  // TODO: When we get proper string enums in typescript make this ReservedType.\n  // Not really worth it to do the whole $Values dance with reservedTypes set.\n  AssignReservedType: ({ reservedType }: { reservedType: string }) =>\n    `Cannot overwrite reserved type ${reservedType}.`,\n  DeclareClassElement:\n    \"The `declare` modifier can only appear on class fields.\",\n  DeclareClassFieldInitializer:\n    \"Initializers are not allowed in fields with the `declare` modifier.\",\n  DuplicateDeclareModuleExports:\n    \"Duplicate `declare module.exports` statement.\",\n  EnumBooleanMemberNotInitialized: ({\n    memberName,\n    enumName,\n  }: {\n    memberName: string;\n    enumName: string;\n  }) =>\n    `Boolean enum members need to be initialized. Use either \\`${memberName} = true,\\` or \\`${memberName} = false,\\` in enum \\`${enumName}\\`.`,\n  EnumDuplicateMemberName: ({\n    memberName,\n    enumName,\n  }: {\n    memberName: string;\n    enumName: string;\n  }) =>\n    `Enum member names need to be unique, but the name \\`${memberName}\\` has already been used before in enum \\`${enumName}\\`.`,\n  EnumInconsistentMemberValues: ({ enumName }: { enumName: string }) =>\n    `Enum \\`${enumName}\\` has inconsistent member initializers. Either use no initializers, or consistently use literals (either booleans, numbers, or strings) for all member initializers.`,\n  EnumInvalidExplicitType: ({\n    invalidEnumType,\n    enumName,\n  }: {\n    invalidEnumType: string;\n    enumName: string;\n  }) =>\n    `Enum type \\`${invalidEnumType}\\` is not valid. Use one of \\`boolean\\`, \\`number\\`, \\`string\\`, or \\`symbol\\` in enum \\`${enumName}\\`.`,\n  EnumInvalidExplicitTypeUnknownSupplied: ({\n    enumName,\n  }: {\n    enumName: string;\n  }) =>\n    `Supplied enum type is not valid. Use one of \\`boolean\\`, \\`number\\`, \\`string\\`, or \\`symbol\\` in enum \\`${enumName}\\`.`,\n\n  // TODO: When moving to typescript, we should either have each of the\n  // following errors only accept the specific strings they want:\n  //\n  // ...PrimaryType: explicitType: \"string\" | \"number\" | \"boolean\"\n  // ...SymbolType: explicitType: \"symbol\"\n  // ...UnknownType: explicitType: null\n  //\n  // Or, alternatively, merge these three errors together into one\n  // `EnumInvalidMemberInitializer` error that can accept `EnumExplicitType`\n  // without alteration, and then just have its message change based on the\n  // explicitType.\n  EnumInvalidMemberInitializerPrimaryType: ({\n    enumName,\n    memberName,\n    explicitType,\n  }: {\n    enumName: string;\n    memberName: string;\n    explicitType: EnumExplicitType;\n  }) =>\n    `Enum \\`${enumName}\\` has type \\`${explicitType}\\`, so the initializer of \\`${memberName}\\` needs to be a ${explicitType} literal.`,\n  EnumInvalidMemberInitializerSymbolType: ({\n    enumName,\n    memberName,\n  }: {\n    enumName: string;\n    memberName: string;\n    explicitType: EnumExplicitType;\n  }) =>\n    `Symbol enum members cannot be initialized. Use \\`${memberName},\\` in enum \\`${enumName}\\`.`,\n  EnumInvalidMemberInitializerUnknownType: ({\n    enumName,\n    memberName,\n  }: {\n    enumName: string;\n    memberName: string;\n    explicitType: EnumExplicitType;\n  }) =>\n    `The enum member initializer for \\`${memberName}\\` needs to be a literal (either a boolean, number, or string) in enum \\`${enumName}\\`.`,\n  EnumInvalidMemberName: ({\n    enumName,\n    memberName,\n    suggestion,\n  }: {\n    enumName: string;\n    memberName: string;\n    suggestion: string;\n  }) =>\n    `Enum member names cannot start with lowercase 'a' through 'z'. Instead of using \\`${memberName}\\`, consider using \\`${suggestion}\\`, in enum \\`${enumName}\\`.`,\n  EnumNumberMemberNotInitialized: ({\n    enumName,\n    memberName,\n  }: {\n    enumName: string;\n    memberName: string;\n  }) =>\n    `Number enum members need to be initialized, e.g. \\`${memberName} = 1\\` in enum \\`${enumName}\\`.`,\n  EnumStringMemberInconsistentlyInitailized: ({\n    enumName,\n  }: {\n    enumName: string;\n  }) =>\n    `String enum members need to consistently either all use initializers, or use no initializers, in enum \\`${enumName}\\`.`,\n  GetterMayNotHaveThisParam: \"A getter cannot have a `this` parameter.\",\n  ImportReflectionHasImportType:\n    \"An `import module` declaration can not use `type` or `typeof` keyword.\",\n  ImportTypeShorthandOnlyInPureImport:\n    \"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.\",\n  InexactInsideExact:\n    \"Explicit inexact syntax cannot appear inside an explicit exact object type.\",\n  InexactInsideNonObject:\n    \"Explicit inexact syntax cannot appear in class or interface definitions.\",\n  InexactVariance: \"Explicit inexact syntax cannot have variance.\",\n  InvalidNonTypeImportInDeclareModule:\n    \"Imports within a `declare module` body must always be `import type` or `import typeof`.\",\n  MissingTypeParamDefault:\n    \"Type parameter declaration needs a default, since a preceding type parameter declaration has a default.\",\n  NestedDeclareModule:\n    \"`declare module` cannot be used inside another `declare module`.\",\n  NestedFlowComment: \"Cannot have a flow comment inside another flow comment.\",\n  PatternIsOptional: {\n    message:\n      \"A binding pattern parameter cannot be optional in an implementation signature.\",\n    // For consistency in TypeScript and Flow error codes\n    ...(!process.env.BABEL_8_BREAKING\n      ? { reasonCode: \"OptionalBindingPattern\" }\n      : {}),\n  },\n  SetterMayNotHaveThisParam: \"A setter cannot have a `this` parameter.\",\n  SpreadVariance: \"Spread properties cannot have variance.\",\n  ThisParamAnnotationRequired:\n    \"A type annotation is required for the `this` parameter.\",\n  ThisParamBannedInConstructor:\n    \"Constructors cannot have a `this` parameter; constructors don't bind `this` like other functions.\",\n  ThisParamMayNotBeOptional: \"The `this` parameter cannot be optional.\",\n  ThisParamMustBeFirst:\n    \"The `this` parameter must be the first function parameter.\",\n  ThisParamNoDefault: \"The `this` parameter may not have a default value.\",\n  TypeBeforeInitializer:\n    \"Type annotations must come before default assignments, e.g. instead of `age = 25: number` use `age: number = 25`.\",\n  TypeCastInPattern:\n    \"The type cast expression is expected to be wrapped with parenthesis.\",\n  UnexpectedExplicitInexactInObject:\n    \"Explicit inexact syntax must appear at the end of an inexact object.\",\n  UnexpectedReservedType: ({ reservedType }: { reservedType: string }) =>\n    `Unexpected reserved type ${reservedType}.`,\n  UnexpectedReservedUnderscore:\n    \"`_` is only allowed as a type argument to call or new.\",\n  UnexpectedSpaceBetweenModuloChecks:\n    \"Spaces between `%` and `checks` are not allowed here.\",\n  UnexpectedSpreadType:\n    \"Spread operator cannot appear in class or interface definitions.\",\n  UnexpectedSubtractionOperand:\n    'Unexpected token, expected \"number\" or \"bigint\".',\n  UnexpectedTokenAfterTypeParameter:\n    \"Expected an arrow function after this type parameter declaration.\",\n  UnexpectedTypeParameterBeforeAsyncArrowFunction:\n    \"Type parameters must come after the async keyword, e.g. instead of `<T> async () => {}`, use `async <T>() => {}`.\",\n  UnsupportedDeclareExportKind: ({\n    unsupportedExportKind,\n    suggestion,\n  }: {\n    unsupportedExportKind: string;\n    suggestion: string;\n  }) =>\n    `\\`declare export ${unsupportedExportKind}\\` is not supported. Use \\`${suggestion}\\` instead.`,\n  UnsupportedStatementInDeclareModule:\n    \"Only declares and type imports are allowed inside declare module.\",\n  UnterminatedFlowComment: \"Unterminated flow-comment.\",\n});\n/* eslint-disable sort-keys */\n\nfunction isEsModuleType(bodyElement: N.Node): boolean {\n  return (\n    bodyElement.type === \"DeclareExportAllDeclaration\" ||\n    (bodyElement.type === \"DeclareExportDeclaration\" &&\n      (!bodyElement.declaration ||\n        (bodyElement.declaration.type !== \"TypeAlias\" &&\n          bodyElement.declaration.type !== \"InterfaceDeclaration\")))\n  );\n}\n\nfunction hasTypeImportKind(node: N.Node): boolean {\n  return node.importKind === \"type\" || node.importKind === \"typeof\";\n}\n\nconst exportSuggestions = {\n  const: \"declare export var\",\n  let: \"declare export var\",\n  type: \"export type\",\n  interface: \"export interface\",\n};\n\n// Like Array#filter, but returns a tuple [ acceptedElements, discardedElements ]\nfunction partition<T>(\n  list: T[],\n  test: (c: T, b: number, a: T[]) => boolean | undefined | null,\n): [T[], T[]] {\n  const list1: T[] = [];\n  const list2: T[] = [];\n  for (let i = 0; i < list.length; i++) {\n    (test(list[i], i, list) ? list1 : list2).push(list[i]);\n  }\n  return [list1, list2];\n}\n\nconst FLOW_PRAGMA_REGEX = /\\*?\\s*@((?:no)?flow)\\b/;\n\n// Flow enums types\ntype EnumExplicitType = null | \"boolean\" | \"number\" | \"string\" | \"symbol\";\n\ntype EnumContext = {\n  enumName: string;\n  explicitType: EnumExplicitType;\n  memberName: string;\n};\n\ntype EnumMemberInit =\n  | {\n      type: \"number\";\n      loc: Position;\n      value: N.Node;\n    }\n  | {\n      type: \"string\";\n      loc: Position;\n      value: N.Node;\n    }\n  | {\n      type: \"boolean\";\n      loc: Position;\n      value: N.Node;\n    }\n  | {\n      type: \"invalid\";\n      loc: Position;\n    }\n  | {\n      type: \"none\";\n      loc: Position;\n    };\n\nexport default (superClass: typeof Parser) =>\n  class FlowParserMixin extends superClass implements Parser {\n    // The value of the @flow/@noflow pragma. Initially undefined, transitions\n    // to \"@flow\" or \"@noflow\" if we see a pragma. Transitions to null if we are\n    // past the initial comment.\n    flowPragma: void | null | \"flow\" | \"noflow\" = undefined;\n\n    getScopeHandler(): {\n      new (...args: any): FlowScopeHandler;\n    } {\n      return FlowScopeHandler;\n    }\n\n    shouldParseTypes(): boolean {\n      return this.getPluginOption(\"flow\", \"all\") || this.flowPragma === \"flow\";\n    }\n\n    shouldParseEnums(): boolean {\n      return !!this.getPluginOption(\"flow\", \"enums\");\n    }\n\n    finishToken(type: TokenType, val: any): void {\n      if (\n        type !== tt.string &&\n        type !== tt.semi &&\n        type !== tt.interpreterDirective\n      ) {\n        if (this.flowPragma === undefined) {\n          this.flowPragma = null;\n        }\n      }\n      super.finishToken(type, val);\n    }\n\n    addComment(comment: N.Comment): void {\n      if (this.flowPragma === undefined) {\n        // Try to parse a flow pragma.\n        const matches = FLOW_PRAGMA_REGEX.exec(comment.value);\n        if (!matches) {\n          // do nothing\n        } else if (matches[1] === \"flow\") {\n          this.flowPragma = \"flow\";\n        } else if (matches[1] === \"noflow\") {\n          this.flowPragma = \"noflow\";\n        } else {\n          throw new Error(\"Unexpected flow pragma\");\n        }\n      }\n      super.addComment(comment);\n    }\n\n    flowParseTypeInitialiser(tok?: TokenType): N.FlowType {\n      const oldInType = this.state.inType;\n      this.state.inType = true;\n      this.expect(tok || tt.colon);\n\n      const type = this.flowParseType();\n      this.state.inType = oldInType;\n      return type;\n    }\n\n    flowParsePredicate(): N.FlowPredicate {\n      const node = this.startNode();\n      const moduloLoc = this.state.startLoc;\n      this.next(); // eat `%`\n      this.expectContextual(tt._checks);\n      // Force '%' and 'checks' to be adjacent\n      if (this.state.lastTokStart > moduloLoc.index + 1) {\n        this.raise(FlowErrors.UnexpectedSpaceBetweenModuloChecks, {\n          at: moduloLoc,\n        });\n      }\n      if (this.eat(tt.parenL)) {\n        node.value = super.parseExpression();\n        this.expect(tt.parenR);\n        return this.finishNode(node, \"DeclaredPredicate\");\n      } else {\n        return this.finishNode(node, \"InferredPredicate\");\n      }\n    }\n\n    flowParseTypeAndPredicateInitialiser(): [\n      N.FlowType | undefined | null,\n      N.FlowPredicate | undefined | null,\n    ] {\n      const oldInType = this.state.inType;\n      this.state.inType = true;\n      this.expect(tt.colon);\n      let type = null;\n      let predicate = null;\n      if (this.match(tt.modulo)) {\n        this.state.inType = oldInType;\n        predicate = this.flowParsePredicate();\n      } else {\n        type = this.flowParseType();\n        this.state.inType = oldInType;\n        if (this.match(tt.modulo)) {\n          predicate = this.flowParsePredicate();\n        }\n      }\n      return [type, predicate];\n    }\n\n    flowParseDeclareClass(\n      node: Undone<N.FlowDeclareClass>,\n    ): N.FlowDeclareClass {\n      this.next();\n      this.flowParseInterfaceish(node, /*isClass*/ true);\n      return this.finishNode(node, \"DeclareClass\");\n    }\n\n    flowParseDeclareFunction(\n      node: Undone<N.FlowDeclareFunction>,\n    ): N.FlowDeclareFunction {\n      this.next();\n\n      const id = (node.id = this.parseIdentifier());\n\n      const typeNode = this.startNode();\n      const typeContainer = this.startNode<N.TypeAnnotation>();\n\n      if (this.match(tt.lt)) {\n        typeNode.typeParameters = this.flowParseTypeParameterDeclaration();\n      } else {\n        typeNode.typeParameters = null;\n      }\n\n      this.expect(tt.parenL);\n      const tmp = this.flowParseFunctionTypeParams();\n      typeNode.params = tmp.params;\n      typeNode.rest = tmp.rest;\n      typeNode.this = tmp._this;\n      this.expect(tt.parenR);\n\n      [typeNode.returnType, node.predicate] =\n        this.flowParseTypeAndPredicateInitialiser();\n\n      typeContainer.typeAnnotation = this.finishNode(\n        typeNode,\n        \"FunctionTypeAnnotation\",\n      );\n\n      id.typeAnnotation = this.finishNode(typeContainer, \"TypeAnnotation\");\n\n      this.resetEndLocation(id);\n      this.semicolon();\n\n      this.scope.declareName(\n        node.id.name,\n        BIND_FLOW_DECLARE_FN,\n        node.id.loc.start,\n      );\n\n      return this.finishNode(node, \"DeclareFunction\");\n    }\n\n    flowParseDeclare(\n      node: Undone<N.FlowDeclare>,\n      insideModule?: boolean,\n    ): N.FlowDeclare {\n      if (this.match(tt._class)) {\n        return this.flowParseDeclareClass(node);\n      } else if (this.match(tt._function)) {\n        return this.flowParseDeclareFunction(node);\n      } else if (this.match(tt._var)) {\n        return this.flowParseDeclareVariable(node);\n      } else if (this.eatContextual(tt._module)) {\n        if (this.match(tt.dot)) {\n          return this.flowParseDeclareModuleExports(node);\n        } else {\n          if (insideModule) {\n            this.raise(FlowErrors.NestedDeclareModule, {\n              at: this.state.lastTokStartLoc,\n            });\n          }\n          return this.flowParseDeclareModule(node);\n        }\n      } else if (this.isContextual(tt._type)) {\n        return this.flowParseDeclareTypeAlias(node);\n      } else if (this.isContextual(tt._opaque)) {\n        return this.flowParseDeclareOpaqueType(node);\n      } else if (this.isContextual(tt._interface)) {\n        return this.flowParseDeclareInterface(node);\n      } else if (this.match(tt._export)) {\n        return this.flowParseDeclareExportDeclaration(node, insideModule);\n      } else {\n        this.unexpected();\n      }\n    }\n\n    flowParseDeclareVariable(\n      node: Undone<N.FlowDeclareVariable>,\n    ): N.FlowDeclareVariable {\n      this.next();\n      node.id = this.flowParseTypeAnnotatableIdentifier(\n        /*allowPrimitiveOverride*/ true,\n      );\n      this.scope.declareName(node.id.name, BIND_VAR, node.id.loc.start);\n      this.semicolon();\n      return this.finishNode(node, \"DeclareVariable\");\n    }\n\n    flowParseDeclareModule(\n      node: Undone<N.FlowDeclareModule>,\n    ): N.FlowDeclareModule {\n      this.scope.enter(SCOPE_OTHER);\n\n      if (this.match(tt.string)) {\n        node.id = super.parseExprAtom();\n      } else {\n        node.id = this.parseIdentifier();\n      }\n\n      const bodyNode = (node.body = this.startNode());\n      // @ts-expect-error refine typings\n      const body = (bodyNode.body = []);\n      this.expect(tt.braceL);\n      while (!this.match(tt.braceR)) {\n        let bodyNode = this.startNode<N.ImportDeclaration>();\n\n        if (this.match(tt._import)) {\n          this.next();\n          if (!this.isContextual(tt._type) && !this.match(tt._typeof)) {\n            this.raise(FlowErrors.InvalidNonTypeImportInDeclareModule, {\n              at: this.state.lastTokStartLoc,\n            });\n          }\n          super.parseImport(bodyNode);\n        } else {\n          this.expectContextual(\n            tt._declare,\n            FlowErrors.UnsupportedStatementInDeclareModule,\n          );\n          // @ts-expect-error refine typings\n          bodyNode = this.flowParseDeclare(bodyNode, true);\n        }\n\n        body.push(bodyNode);\n      }\n\n      this.scope.exit();\n\n      this.expect(tt.braceR);\n\n      this.finishNode(bodyNode, \"BlockStatement\");\n\n      let kind: \"CommonJS\" | \"ES\" | null = null;\n      let hasModuleExport = false;\n      body.forEach(bodyElement => {\n        if (isEsModuleType(bodyElement)) {\n          if (kind === \"CommonJS\") {\n            this.raise(FlowErrors.AmbiguousDeclareModuleKind, {\n              at: bodyElement,\n            });\n          }\n          kind = \"ES\";\n        } else if (bodyElement.type === \"DeclareModuleExports\") {\n          if (hasModuleExport) {\n            this.raise(FlowErrors.DuplicateDeclareModuleExports, {\n              at: bodyElement,\n            });\n          }\n          if (kind === \"ES\") {\n            this.raise(FlowErrors.AmbiguousDeclareModuleKind, {\n              at: bodyElement,\n            });\n          }\n          kind = \"CommonJS\";\n          hasModuleExport = true;\n        }\n      });\n\n      node.kind = kind || \"CommonJS\";\n      return this.finishNode(node, \"DeclareModule\");\n    }\n\n    flowParseDeclareExportDeclaration(\n      node: Undone<N.FlowDeclareExportDeclaration>,\n      insideModule?: boolean | null,\n    ): N.FlowDeclareExportDeclaration {\n      this.expect(tt._export);\n\n      if (this.eat(tt._default)) {\n        if (this.match(tt._function) || this.match(tt._class)) {\n          // declare export default class ...\n          // declare export default function ...\n          node.declaration = this.flowParseDeclare(this.startNode());\n        } else {\n          // declare export default [type];\n          node.declaration = this.flowParseType();\n          this.semicolon();\n        }\n        node.default = true;\n\n        return this.finishNode(node, \"DeclareExportDeclaration\");\n      } else {\n        if (\n          this.match(tt._const) ||\n          this.isLet() ||\n          ((this.isContextual(tt._type) || this.isContextual(tt._interface)) &&\n            !insideModule)\n        ) {\n          const label = this.state.value as\n            | \"const\"\n            | \"let\"\n            | \"type\"\n            | \"interface\";\n          throw this.raise(FlowErrors.UnsupportedDeclareExportKind, {\n            at: this.state.startLoc,\n            unsupportedExportKind: label,\n            suggestion: exportSuggestions[label],\n          });\n        }\n\n        if (\n          this.match(tt._var) || // declare export var ...\n          this.match(tt._function) || // declare export function ...\n          this.match(tt._class) || // declare export class ...\n          this.isContextual(tt._opaque) // declare export opaque ..\n        ) {\n          node.declaration = this.flowParseDeclare(this.startNode());\n          node.default = false;\n\n          return this.finishNode(node, \"DeclareExportDeclaration\");\n        } else if (\n          this.match(tt.star) || // declare export * from ''\n          this.match(tt.braceL) || // declare export {} ...\n          this.isContextual(tt._interface) || // declare export interface ...\n          this.isContextual(tt._type) || // declare export type ...\n          this.isContextual(tt._opaque) // declare export opaque type ...\n        ) {\n          node = this.parseExport(\n            node as Undone<N.ExportNamedDeclaration | N.ExportAllDeclaration>,\n            /* decorators */ null,\n          );\n          if (node.type === \"ExportNamedDeclaration\") {\n            node.type = \"ExportDeclaration\";\n            node.default = false;\n            delete node.exportKind;\n          }\n\n          node.type = \"Declare\" + node.type;\n\n          return node as N.Node;\n        }\n      }\n\n      this.unexpected();\n    }\n\n    flowParseDeclareModuleExports(\n      node: Undone<N.FlowDeclareModuleExports>,\n    ): N.FlowDeclareModuleExports {\n      this.next();\n      this.expectContextual(tt._exports);\n      node.typeAnnotation = this.flowParseTypeAnnotation();\n      this.semicolon();\n\n      return this.finishNode(node, \"DeclareModuleExports\");\n    }\n\n    flowParseDeclareTypeAlias(\n      node: Undone<N.FlowDeclareTypeAlias>,\n    ): N.FlowDeclareTypeAlias {\n      this.next();\n      const finished = this.flowParseTypeAlias(node);\n      // Don't do finishNode as we don't want to process comments twice\n      finished.type = \"DeclareTypeAlias\";\n      return finished;\n    }\n\n    flowParseDeclareOpaqueType(\n      node: Undone<N.FlowDeclareOpaqueType>,\n    ): N.FlowDeclareOpaqueType {\n      this.next();\n      const finished = this.flowParseOpaqueType(node, true);\n      // Don't do finishNode as we don't want to process comments twice\n      finished.type = \"DeclareOpaqueType\";\n      return finished;\n    }\n\n    flowParseDeclareInterface(\n      node: Undone<N.FlowDeclareInterface>,\n    ): N.FlowDeclareInterface {\n      this.next();\n      this.flowParseInterfaceish(node, /* isClass */ false);\n      return this.finishNode(node, \"DeclareInterface\");\n    }\n\n    // Interfaces\n\n    flowParseInterfaceish(node: Undone<N.FlowDeclare>, isClass: boolean): void {\n      node.id = this.flowParseRestrictedIdentifier(\n        /* liberal */ !isClass,\n        /* declaration */ true,\n      );\n\n      this.scope.declareName(\n        node.id.name,\n        isClass ? BIND_FUNCTION : BIND_LEXICAL,\n        node.id.loc.start,\n      );\n\n      if (this.match(tt.lt)) {\n        node.typeParameters = this.flowParseTypeParameterDeclaration();\n      } else {\n        node.typeParameters = null;\n      }\n\n      node.extends = [];\n\n      if (this.eat(tt._extends)) {\n        do {\n          node.extends.push(this.flowParseInterfaceExtends());\n        } while (!isClass && this.eat(tt.comma));\n      }\n\n      if (isClass) {\n        node.implements = [];\n        node.mixins = [];\n\n        if (this.eatContextual(tt._mixins)) {\n          do {\n            node.mixins.push(this.flowParseInterfaceExtends());\n          } while (this.eat(tt.comma));\n        }\n\n        if (this.eatContextual(tt._implements)) {\n          do {\n            node.implements.push(this.flowParseInterfaceExtends());\n          } while (this.eat(tt.comma));\n        }\n      }\n\n      node.body = this.flowParseObjectType({\n        allowStatic: isClass,\n        allowExact: false,\n        allowSpread: false,\n        allowProto: isClass,\n        allowInexact: false,\n      });\n    }\n\n    flowParseInterfaceExtends(): N.FlowInterfaceExtends {\n      const node = this.startNode();\n\n      node.id = this.flowParseQualifiedTypeIdentifier();\n      if (this.match(tt.lt)) {\n        node.typeParameters = this.flowParseTypeParameterInstantiation();\n      } else {\n        node.typeParameters = null;\n      }\n\n      return this.finishNode(node, \"InterfaceExtends\");\n    }\n\n    flowParseInterface(node: Undone<N.FlowInterface>): N.FlowInterface {\n      this.flowParseInterfaceish(node, /* isClass */ false);\n      return this.finishNode(node, \"InterfaceDeclaration\");\n    }\n\n    checkNotUnderscore(word: string) {\n      if (word === \"_\") {\n        this.raise(FlowErrors.UnexpectedReservedUnderscore, {\n          at: this.state.startLoc,\n        });\n      }\n    }\n\n    checkReservedType(word: string, startLoc: Position, declaration?: boolean) {\n      if (!reservedTypes.has(word)) return;\n\n      this.raise(\n        declaration\n          ? FlowErrors.AssignReservedType\n          : FlowErrors.UnexpectedReservedType,\n        {\n          at: startLoc,\n          reservedType: word,\n        },\n      );\n    }\n\n    flowParseRestrictedIdentifier(\n      liberal?: boolean,\n      declaration?: boolean,\n    ): N.Identifier {\n      this.checkReservedType(\n        this.state.value,\n        this.state.startLoc,\n        declaration,\n      );\n      return this.parseIdentifier(liberal);\n    }\n\n    // Type aliases\n\n    flowParseTypeAlias(node: Undone<N.FlowTypeAlias>): N.FlowTypeAlias {\n      node.id = this.flowParseRestrictedIdentifier(\n        /* liberal */ false,\n        /* declaration */ true,\n      );\n      this.scope.declareName(node.id.name, BIND_LEXICAL, node.id.loc.start);\n\n      if (this.match(tt.lt)) {\n        node.typeParameters = this.flowParseTypeParameterDeclaration();\n      } else {\n        node.typeParameters = null;\n      }\n\n      node.right = this.flowParseTypeInitialiser(tt.eq);\n      this.semicolon();\n\n      return this.finishNode(node, \"TypeAlias\");\n    }\n\n    flowParseOpaqueType(\n      node: Undone<N.FlowOpaqueType>,\n      declare: boolean,\n    ): N.FlowOpaqueType {\n      this.expectContextual(tt._type);\n      node.id = this.flowParseRestrictedIdentifier(\n        /* liberal */ true,\n        /* declaration */ true,\n      );\n      this.scope.declareName(node.id.name, BIND_LEXICAL, node.id.loc.start);\n\n      if (this.match(tt.lt)) {\n        node.typeParameters = this.flowParseTypeParameterDeclaration();\n      } else {\n        node.typeParameters = null;\n      }\n\n      // Parse the supertype\n      node.supertype = null;\n      if (this.match(tt.colon)) {\n        node.supertype = this.flowParseTypeInitialiser(tt.colon);\n      }\n\n      node.impltype = null;\n      if (!declare) {\n        node.impltype = this.flowParseTypeInitialiser(tt.eq);\n      }\n      this.semicolon();\n\n      return this.finishNode(node, \"OpaqueType\");\n    }\n\n    // Type annotations\n\n    flowParseTypeParameter(requireDefault: boolean = false): N.TypeParameter {\n      const nodeStartLoc = this.state.startLoc;\n\n      const node = this.startNode<N.TypeParameter>();\n\n      const variance = this.flowParseVariance();\n\n      const ident = this.flowParseTypeAnnotatableIdentifier();\n      node.name = ident.name;\n      // @ts-expect-error migrate to Babel types\n      node.variance = variance;\n      // @ts-expect-error migrate to Babel types\n      node.bound = ident.typeAnnotation;\n\n      if (this.match(tt.eq)) {\n        this.eat(tt.eq);\n        // @ts-expect-error migrate to Babel types\n        node.default = this.flowParseType();\n      } else {\n        if (requireDefault) {\n          this.raise(FlowErrors.MissingTypeParamDefault, { at: nodeStartLoc });\n        }\n      }\n\n      return this.finishNode(node, \"TypeParameter\");\n    }\n\n    flowParseTypeParameterDeclaration(): N.TypeParameterDeclaration {\n      const oldInType = this.state.inType;\n      const node = this.startNode<N.TypeParameterDeclaration>();\n      node.params = [];\n\n      this.state.inType = true;\n\n      // istanbul ignore else: this condition is already checked at all call sites\n      if (this.match(tt.lt) || this.match(tt.jsxTagStart)) {\n        this.next();\n      } else {\n        this.unexpected();\n      }\n\n      let defaultRequired = false;\n\n      do {\n        const typeParameter = this.flowParseTypeParameter(defaultRequired);\n\n        node.params.push(typeParameter);\n\n        if (typeParameter.default) {\n          defaultRequired = true;\n        }\n\n        if (!this.match(tt.gt)) {\n          this.expect(tt.comma);\n        }\n      } while (!this.match(tt.gt));\n      this.expect(tt.gt);\n\n      this.state.inType = oldInType;\n\n      return this.finishNode(node, \"TypeParameterDeclaration\");\n    }\n\n    flowParseTypeParameterInstantiation(): N.TypeParameterInstantiation {\n      const node = this.startNode<N.TypeParameterInstantiation>();\n      const oldInType = this.state.inType;\n      node.params = [];\n\n      this.state.inType = true;\n\n      this.expect(tt.lt);\n      const oldNoAnonFunctionType = this.state.noAnonFunctionType;\n      this.state.noAnonFunctionType = false;\n      while (!this.match(tt.gt)) {\n        node.params.push(this.flowParseType());\n        if (!this.match(tt.gt)) {\n          this.expect(tt.comma);\n        }\n      }\n      this.state.noAnonFunctionType = oldNoAnonFunctionType;\n      this.expect(tt.gt);\n\n      this.state.inType = oldInType;\n\n      return this.finishNode(node, \"TypeParameterInstantiation\");\n    }\n\n    flowParseTypeParameterInstantiationCallOrNew(): N.TypeParameterInstantiation {\n      const node = this.startNode<N.TypeParameterInstantiation>();\n      const oldInType = this.state.inType;\n      node.params = [];\n\n      this.state.inType = true;\n\n      this.expect(tt.lt);\n      while (!this.match(tt.gt)) {\n        node.params.push(this.flowParseTypeOrImplicitInstantiation());\n        if (!this.match(tt.gt)) {\n          this.expect(tt.comma);\n        }\n      }\n      this.expect(tt.gt);\n\n      this.state.inType = oldInType;\n\n      return this.finishNode(node, \"TypeParameterInstantiation\");\n    }\n\n    flowParseInterfaceType(): N.FlowInterfaceType {\n      const node = this.startNode<N.FlowInterfaceType>();\n      this.expectContextual(tt._interface);\n\n      node.extends = [];\n      if (this.eat(tt._extends)) {\n        do {\n          node.extends.push(this.flowParseInterfaceExtends());\n        } while (this.eat(tt.comma));\n      }\n\n      node.body = this.flowParseObjectType({\n        allowStatic: false,\n        allowExact: false,\n        allowSpread: false,\n        allowProto: false,\n        allowInexact: false,\n      });\n\n      return this.finishNode(node, \"InterfaceTypeAnnotation\");\n    }\n\n    flowParseObjectPropertyKey(): N.Expression {\n      return this.match(tt.num) || this.match(tt.string)\n        ? super.parseExprAtom()\n        : this.parseIdentifier(true);\n    }\n\n    flowParseObjectTypeIndexer(\n      node: Undone<N.FlowObjectTypeIndexer>,\n      isStatic: boolean,\n      variance?: N.FlowVariance | null,\n    ): N.FlowObjectTypeIndexer {\n      node.static = isStatic;\n\n      // Note: bracketL has already been consumed\n      if (this.lookahead().type === tt.colon) {\n        node.id = this.flowParseObjectPropertyKey();\n        node.key = this.flowParseTypeInitialiser();\n      } else {\n        node.id = null;\n        node.key = this.flowParseType();\n      }\n      this.expect(tt.bracketR);\n      node.value = this.flowParseTypeInitialiser();\n      node.variance = variance;\n\n      return this.finishNode(node, \"ObjectTypeIndexer\");\n    }\n\n    flowParseObjectTypeInternalSlot(\n      node: Undone<N.FlowObjectTypeInternalSlot>,\n      isStatic: boolean,\n    ): N.FlowObjectTypeInternalSlot {\n      node.static = isStatic;\n      // Note: both bracketL have already been consumed\n      node.id = this.flowParseObjectPropertyKey();\n      this.expect(tt.bracketR);\n      this.expect(tt.bracketR);\n      if (this.match(tt.lt) || this.match(tt.parenL)) {\n        node.method = true;\n        node.optional = false;\n        node.value = this.flowParseObjectTypeMethodish(\n          this.startNodeAt(node.loc.start),\n        );\n      } else {\n        node.method = false;\n        if (this.eat(tt.question)) {\n          node.optional = true;\n        }\n        node.value = this.flowParseTypeInitialiser();\n      }\n      return this.finishNode(node, \"ObjectTypeInternalSlot\");\n    }\n\n    flowParseObjectTypeMethodish(\n      node: Undone<N.FlowFunctionTypeAnnotation>,\n    ): N.FlowFunctionTypeAnnotation {\n      node.params = [];\n      node.rest = null;\n      node.typeParameters = null;\n      node.this = null;\n\n      if (this.match(tt.lt)) {\n        node.typeParameters = this.flowParseTypeParameterDeclaration();\n      }\n\n      this.expect(tt.parenL);\n      if (this.match(tt._this)) {\n        node.this = this.flowParseFunctionTypeParam(/* first */ true);\n        // match Flow parser behavior\n        node.this.name = null;\n        if (!this.match(tt.parenR)) {\n          this.expect(tt.comma);\n        }\n      }\n      while (!this.match(tt.parenR) && !this.match(tt.ellipsis)) {\n        node.params.push(this.flowParseFunctionTypeParam(false));\n        if (!this.match(tt.parenR)) {\n          this.expect(tt.comma);\n        }\n      }\n\n      if (this.eat(tt.ellipsis)) {\n        node.rest = this.flowParseFunctionTypeParam(false);\n      }\n      this.expect(tt.parenR);\n      node.returnType = this.flowParseTypeInitialiser();\n\n      return this.finishNode(node, \"FunctionTypeAnnotation\");\n    }\n\n    flowParseObjectTypeCallProperty(\n      node: Undone<N.FlowObjectTypeCallProperty>,\n      isStatic: boolean,\n    ): N.FlowObjectTypeCallProperty {\n      const valueNode = this.startNode();\n      node.static = isStatic;\n      node.value = this.flowParseObjectTypeMethodish(valueNode);\n      return this.finishNode(node, \"ObjectTypeCallProperty\");\n    }\n\n    flowParseObjectType({\n      allowStatic,\n      allowExact,\n      allowSpread,\n      allowProto,\n      allowInexact,\n    }: {\n      allowStatic: boolean;\n      allowExact: boolean;\n      allowSpread: boolean;\n      allowProto: boolean;\n      allowInexact: boolean;\n    }): N.FlowObjectTypeAnnotation {\n      const oldInType = this.state.inType;\n      this.state.inType = true;\n\n      const nodeStart = this.startNode();\n\n      nodeStart.callProperties = [];\n      nodeStart.properties = [];\n      nodeStart.indexers = [];\n      nodeStart.internalSlots = [];\n\n      let endDelim;\n      let exact;\n      let inexact = false;\n      if (allowExact && this.match(tt.braceBarL)) {\n        this.expect(tt.braceBarL);\n        endDelim = tt.braceBarR;\n        exact = true;\n      } else {\n        this.expect(tt.braceL);\n        endDelim = tt.braceR;\n        exact = false;\n      }\n\n      nodeStart.exact = exact;\n\n      while (!this.match(endDelim)) {\n        let isStatic = false;\n        let protoStartLoc: Position | undefined | null = null;\n        let inexactStartLoc: Position | undefined | null = null;\n        const node = this.startNode();\n\n        if (allowProto && this.isContextual(tt._proto)) {\n          const lookahead = this.lookahead();\n\n          if (lookahead.type !== tt.colon && lookahead.type !== tt.question) {\n            this.next();\n            protoStartLoc = this.state.startLoc;\n            allowStatic = false;\n          }\n        }\n\n        if (allowStatic && this.isContextual(tt._static)) {\n          const lookahead = this.lookahead();\n\n          // static is a valid identifier name\n          if (lookahead.type !== tt.colon && lookahead.type !== tt.question) {\n            this.next();\n            isStatic = true;\n          }\n        }\n\n        const variance = this.flowParseVariance();\n\n        if (this.eat(tt.bracketL)) {\n          if (protoStartLoc != null) {\n            this.unexpected(protoStartLoc);\n          }\n          if (this.eat(tt.bracketL)) {\n            if (variance) {\n              this.unexpected(variance.loc.start);\n            }\n            nodeStart.internalSlots.push(\n              this.flowParseObjectTypeInternalSlot(node, isStatic),\n            );\n          } else {\n            nodeStart.indexers.push(\n              this.flowParseObjectTypeIndexer(node, isStatic, variance),\n            );\n          }\n        } else if (this.match(tt.parenL) || this.match(tt.lt)) {\n          if (protoStartLoc != null) {\n            this.unexpected(protoStartLoc);\n          }\n          if (variance) {\n            this.unexpected(variance.loc.start);\n          }\n          nodeStart.callProperties.push(\n            this.flowParseObjectTypeCallProperty(node, isStatic),\n          );\n        } else {\n          let kind = \"init\";\n\n          if (this.isContextual(tt._get) || this.isContextual(tt._set)) {\n            const lookahead = this.lookahead();\n            if (tokenIsLiteralPropertyName(lookahead.type)) {\n              kind = this.state.value;\n              this.next();\n            }\n          }\n\n          const propOrInexact = this.flowParseObjectTypeProperty(\n            node,\n            isStatic,\n            protoStartLoc,\n            variance,\n            kind,\n            allowSpread,\n            allowInexact ?? !exact,\n          );\n\n          if (propOrInexact === null) {\n            inexact = true;\n            inexactStartLoc = this.state.lastTokStartLoc;\n          } else {\n            nodeStart.properties.push(propOrInexact);\n          }\n        }\n\n        this.flowObjectTypeSemicolon();\n\n        if (\n          inexactStartLoc &&\n          !this.match(tt.braceR) &&\n          !this.match(tt.braceBarR)\n        ) {\n          this.raise(FlowErrors.UnexpectedExplicitInexactInObject, {\n            at: inexactStartLoc,\n          });\n        }\n      }\n\n      this.expect(endDelim);\n\n      /* The inexact flag should only be added on ObjectTypeAnnotations that\n       * are not the body of an interface, declare interface, or declare class.\n       * Since spreads are only allowed in object types, checking that is\n       * sufficient here.\n       */\n      if (allowSpread) {\n        nodeStart.inexact = inexact;\n      }\n\n      const out = this.finishNode(nodeStart, \"ObjectTypeAnnotation\");\n\n      this.state.inType = oldInType;\n\n      return out;\n    }\n\n    flowParseObjectTypeProperty(\n      node: Undone<N.FlowObjectTypeProperty | N.FlowObjectTypeSpreadProperty>,\n      isStatic: boolean,\n      protoStartLoc: Position | undefined | null,\n      variance: N.FlowVariance | undefined | null,\n      kind: string,\n      allowSpread: boolean,\n      allowInexact: boolean,\n    ): N.FlowObjectTypeProperty | N.FlowObjectTypeSpreadProperty | null {\n      if (this.eat(tt.ellipsis)) {\n        const isInexactToken =\n          this.match(tt.comma) ||\n          this.match(tt.semi) ||\n          this.match(tt.braceR) ||\n          this.match(tt.braceBarR);\n\n        if (isInexactToken) {\n          if (!allowSpread) {\n            this.raise(FlowErrors.InexactInsideNonObject, {\n              at: this.state.lastTokStartLoc,\n            });\n          } else if (!allowInexact) {\n            this.raise(FlowErrors.InexactInsideExact, {\n              at: this.state.lastTokStartLoc,\n            });\n          }\n          if (variance) {\n            this.raise(FlowErrors.InexactVariance, { at: variance });\n          }\n\n          return null;\n        }\n\n        if (!allowSpread) {\n          this.raise(FlowErrors.UnexpectedSpreadType, {\n            at: this.state.lastTokStartLoc,\n          });\n        }\n        if (protoStartLoc != null) {\n          this.unexpected(protoStartLoc);\n        }\n        if (variance) {\n          this.raise(FlowErrors.SpreadVariance, { at: variance });\n        }\n\n        node.argument = this.flowParseType();\n        return this.finishNode(node, \"ObjectTypeSpreadProperty\");\n      } else {\n        node.key = this.flowParseObjectPropertyKey();\n        node.static = isStatic;\n        node.proto = protoStartLoc != null;\n        node.kind = kind;\n\n        let optional = false;\n        if (this.match(tt.lt) || this.match(tt.parenL)) {\n          // This is a method property\n          node.method = true;\n\n          if (protoStartLoc != null) {\n            this.unexpected(protoStartLoc);\n          }\n          if (variance) {\n            this.unexpected(variance.loc.start);\n          }\n\n          node.value = this.flowParseObjectTypeMethodish(\n            this.startNodeAt(node.loc.start),\n          );\n          if (kind === \"get\" || kind === \"set\") {\n            this.flowCheckGetterSetterParams(node);\n          }\n          /** Declared classes/interfaces do not allow spread */\n          if (\n            !allowSpread &&\n            node.key.name === \"constructor\" &&\n            node.value.this\n          ) {\n            this.raise(FlowErrors.ThisParamBannedInConstructor, {\n              at: node.value.this,\n            });\n          }\n        } else {\n          if (kind !== \"init\") this.unexpected();\n\n          node.method = false;\n\n          if (this.eat(tt.question)) {\n            optional = true;\n          }\n          node.value = this.flowParseTypeInitialiser();\n          node.variance = variance;\n        }\n\n        node.optional = optional;\n\n        return this.finishNode(node, \"ObjectTypeProperty\");\n      }\n    }\n\n    // This is similar to checkGetterSetterParams, but as\n    // @babel/parser uses non estree properties we cannot reuse it here\n    flowCheckGetterSetterParams(\n      property: Undone<\n        N.FlowObjectTypeProperty | N.FlowObjectTypeSpreadProperty\n      >,\n    ): void {\n      const paramCount = property.kind === \"get\" ? 0 : 1;\n      const length =\n        property.value.params.length + (property.value.rest ? 1 : 0);\n\n      if (property.value.this) {\n        this.raise(\n          property.kind === \"get\"\n            ? FlowErrors.GetterMayNotHaveThisParam\n            : FlowErrors.SetterMayNotHaveThisParam,\n          { at: property.value.this },\n        );\n      }\n\n      if (length !== paramCount) {\n        this.raise(\n          property.kind === \"get\"\n            ? Errors.BadGetterArity\n            : Errors.BadSetterArity,\n          { at: property },\n        );\n      }\n\n      if (property.kind === \"set\" && property.value.rest) {\n        this.raise(Errors.BadSetterRestParameter, { at: property });\n      }\n    }\n\n    flowObjectTypeSemicolon(): void {\n      if (\n        !this.eat(tt.semi) &&\n        !this.eat(tt.comma) &&\n        !this.match(tt.braceR) &&\n        !this.match(tt.braceBarR)\n      ) {\n        this.unexpected();\n      }\n    }\n\n    flowParseQualifiedTypeIdentifier(\n      startLoc?: Position,\n      id?: N.Identifier,\n    ): N.FlowQualifiedTypeIdentifier {\n      startLoc ??= this.state.startLoc;\n      let node: N.Identifier | N.FlowQualifiedTypeIdentifier =\n        id || this.flowParseRestrictedIdentifier(true);\n\n      while (this.eat(tt.dot)) {\n        const node2 = this.startNodeAt<N.FlowQualifiedTypeIdentifier>(startLoc);\n        node2.qualification = node;\n        node2.id = this.flowParseRestrictedIdentifier(true);\n        node = this.finishNode(node2, \"QualifiedTypeIdentifier\");\n      }\n\n      return node;\n    }\n\n    flowParseGenericType(\n      startLoc: Position,\n      id: N.Identifier,\n    ): N.FlowGenericTypeAnnotation {\n      const node = this.startNodeAt(startLoc);\n\n      node.typeParameters = null;\n      node.id = this.flowParseQualifiedTypeIdentifier(startLoc, id);\n\n      if (this.match(tt.lt)) {\n        node.typeParameters = this.flowParseTypeParameterInstantiation();\n      }\n\n      return this.finishNode(node, \"GenericTypeAnnotation\");\n    }\n\n    flowParseTypeofType(): N.FlowTypeofTypeAnnotation {\n      const node = this.startNode();\n      this.expect(tt._typeof);\n      node.argument = this.flowParsePrimaryType();\n      return this.finishNode(node, \"TypeofTypeAnnotation\");\n    }\n\n    flowParseTupleType(): N.FlowTupleTypeAnnotation {\n      const node = this.startNode();\n      node.types = [];\n      this.expect(tt.bracketL);\n      // We allow trailing commas\n      while (this.state.pos < this.length && !this.match(tt.bracketR)) {\n        node.types.push(this.flowParseType());\n        if (this.match(tt.bracketR)) break;\n        this.expect(tt.comma);\n      }\n      this.expect(tt.bracketR);\n      return this.finishNode(node, \"TupleTypeAnnotation\");\n    }\n\n    flowParseFunctionTypeParam(first: boolean): N.FlowFunctionTypeParam {\n      let name = null;\n      let optional = false;\n      let typeAnnotation = null;\n      const node = this.startNode<N.FlowFunctionTypeParam>();\n      const lh = this.lookahead();\n      const isThis = this.state.type === tt._this;\n\n      if (lh.type === tt.colon || lh.type === tt.question) {\n        if (isThis && !first) {\n          this.raise(FlowErrors.ThisParamMustBeFirst, { at: node });\n        }\n        name = this.parseIdentifier(isThis);\n        if (this.eat(tt.question)) {\n          optional = true;\n          if (isThis) {\n            this.raise(FlowErrors.ThisParamMayNotBeOptional, { at: node });\n          }\n        }\n        typeAnnotation = this.flowParseTypeInitialiser();\n      } else {\n        typeAnnotation = this.flowParseType();\n      }\n      node.name = name;\n      node.optional = optional;\n      node.typeAnnotation = typeAnnotation;\n      return this.finishNode(node, \"FunctionTypeParam\");\n    }\n\n    reinterpretTypeAsFunctionTypeParam(\n      type: N.FlowType,\n    ): N.FlowFunctionTypeParam {\n      const node = this.startNodeAt(type.loc.start);\n      node.name = null;\n      node.optional = false;\n      node.typeAnnotation = type;\n      return this.finishNode(node, \"FunctionTypeParam\");\n    }\n\n    flowParseFunctionTypeParams(params: N.FlowFunctionTypeParam[] = []): {\n      params: N.FlowFunctionTypeParam[];\n      rest: N.FlowFunctionTypeParam | undefined | null;\n      _this: N.FlowFunctionTypeParam | undefined | null;\n    } {\n      let rest: N.FlowFunctionTypeParam | undefined | null = null;\n      let _this: N.FlowFunctionTypeParam | undefined | null = null;\n      if (this.match(tt._this)) {\n        _this = this.flowParseFunctionTypeParam(/* first */ true);\n        // match Flow parser behavior\n        _this.name = null;\n        if (!this.match(tt.parenR)) {\n          this.expect(tt.comma);\n        }\n      }\n      while (!this.match(tt.parenR) && !this.match(tt.ellipsis)) {\n        params.push(this.flowParseFunctionTypeParam(false));\n        if (!this.match(tt.parenR)) {\n          this.expect(tt.comma);\n        }\n      }\n      if (this.eat(tt.ellipsis)) {\n        rest = this.flowParseFunctionTypeParam(false);\n      }\n      return { params, rest, _this };\n    }\n\n    flowIdentToTypeAnnotation(\n      startLoc: Position,\n      node: Undone<N.FlowTypeAnnotation>,\n      id: N.Identifier,\n    ): N.FlowTypeAnnotation {\n      switch (id.name) {\n        case \"any\":\n          return this.finishNode(node, \"AnyTypeAnnotation\");\n\n        case \"bool\":\n        case \"boolean\":\n          return this.finishNode(node, \"BooleanTypeAnnotation\");\n\n        case \"mixed\":\n          return this.finishNode(node, \"MixedTypeAnnotation\");\n\n        case \"empty\":\n          return this.finishNode(node, \"EmptyTypeAnnotation\");\n\n        case \"number\":\n          return this.finishNode(node, \"NumberTypeAnnotation\");\n\n        case \"string\":\n          return this.finishNode(node, \"StringTypeAnnotation\");\n\n        case \"symbol\":\n          return this.finishNode(node, \"SymbolTypeAnnotation\");\n\n        default:\n          this.checkNotUnderscore(id.name);\n          return this.flowParseGenericType(startLoc, id);\n      }\n    }\n\n    // The parsing of types roughly parallels the parsing of expressions, and\n    // primary types are kind of like primary expressions...they're the\n    // primitives with which other types are constructed.\n    flowParsePrimaryType(): N.FlowTypeAnnotation {\n      const startLoc = this.state.startLoc;\n      const node = this.startNode();\n      let tmp;\n      let type;\n      let isGroupedType = false;\n      const oldNoAnonFunctionType = this.state.noAnonFunctionType;\n\n      switch (this.state.type) {\n        case tt.braceL:\n          return this.flowParseObjectType({\n            allowStatic: false,\n            allowExact: false,\n            allowSpread: true,\n            allowProto: false,\n            allowInexact: true,\n          });\n\n        case tt.braceBarL:\n          return this.flowParseObjectType({\n            allowStatic: false,\n            allowExact: true,\n            allowSpread: true,\n            allowProto: false,\n            allowInexact: false,\n          });\n\n        case tt.bracketL:\n          this.state.noAnonFunctionType = false;\n          type = this.flowParseTupleType();\n          this.state.noAnonFunctionType = oldNoAnonFunctionType;\n          return type;\n\n        case tt.lt:\n          node.typeParameters = this.flowParseTypeParameterDeclaration();\n          this.expect(tt.parenL);\n          tmp = this.flowParseFunctionTypeParams();\n          node.params = tmp.params;\n          node.rest = tmp.rest;\n          node.this = tmp._this;\n          this.expect(tt.parenR);\n\n          this.expect(tt.arrow);\n\n          node.returnType = this.flowParseType();\n\n          return this.finishNode(node, \"FunctionTypeAnnotation\");\n\n        case tt.parenL:\n          this.next();\n\n          // Check to see if this is actually a grouped type\n          if (!this.match(tt.parenR) && !this.match(tt.ellipsis)) {\n            if (tokenIsIdentifier(this.state.type) || this.match(tt._this)) {\n              const token = this.lookahead().type;\n              isGroupedType = token !== tt.question && token !== tt.colon;\n            } else {\n              isGroupedType = true;\n            }\n          }\n\n          if (isGroupedType) {\n            this.state.noAnonFunctionType = false;\n            type = this.flowParseType();\n            this.state.noAnonFunctionType = oldNoAnonFunctionType;\n\n            // A `,` or a `) =>` means this is an anonymous function type\n            if (\n              this.state.noAnonFunctionType ||\n              !(\n                this.match(tt.comma) ||\n                (this.match(tt.parenR) && this.lookahead().type === tt.arrow)\n              )\n            ) {\n              this.expect(tt.parenR);\n              return type;\n            } else {\n              // Eat a comma if there is one\n              this.eat(tt.comma);\n            }\n          }\n\n          if (type) {\n            tmp = this.flowParseFunctionTypeParams([\n              this.reinterpretTypeAsFunctionTypeParam(type),\n            ]);\n          } else {\n            tmp = this.flowParseFunctionTypeParams();\n          }\n\n          node.params = tmp.params;\n          node.rest = tmp.rest;\n          node.this = tmp._this;\n\n          this.expect(tt.parenR);\n\n          this.expect(tt.arrow);\n\n          node.returnType = this.flowParseType();\n\n          node.typeParameters = null;\n\n          return this.finishNode(node, \"FunctionTypeAnnotation\");\n\n        case tt.string:\n          return this.parseLiteral<N.StringLiteralTypeAnnotation>(\n            this.state.value,\n            \"StringLiteralTypeAnnotation\",\n          );\n\n        case tt._true:\n        case tt._false:\n          node.value = this.match(tt._true);\n          this.next();\n          return this.finishNode(\n            node as Undone<N.BooleanLiteralTypeAnnotation>,\n            \"BooleanLiteralTypeAnnotation\",\n          );\n\n        case tt.plusMin:\n          if (this.state.value === \"-\") {\n            this.next();\n            if (this.match(tt.num)) {\n              return this.parseLiteralAtNode<N.NumberLiteralTypeAnnotation>(\n                -this.state.value,\n                \"NumberLiteralTypeAnnotation\",\n                node,\n              );\n            }\n\n            if (this.match(tt.bigint)) {\n              return this.parseLiteralAtNode<N.BigIntLiteralTypeAnnotation>(\n                -this.state.value,\n                \"BigIntLiteralTypeAnnotation\",\n                node,\n              );\n            }\n\n            throw this.raise(FlowErrors.UnexpectedSubtractionOperand, {\n              at: this.state.startLoc,\n            });\n          }\n          this.unexpected();\n          return;\n        case tt.num:\n          return this.parseLiteral(\n            this.state.value,\n            \"NumberLiteralTypeAnnotation\",\n          );\n\n        case tt.bigint:\n          return this.parseLiteral(\n            this.state.value,\n            \"BigIntLiteralTypeAnnotation\",\n          );\n\n        case tt._void:\n          this.next();\n          return this.finishNode(node, \"VoidTypeAnnotation\");\n\n        case tt._null:\n          this.next();\n          return this.finishNode(node, \"NullLiteralTypeAnnotation\");\n\n        case tt._this:\n          this.next();\n          return this.finishNode(node, \"ThisTypeAnnotation\");\n\n        case tt.star:\n          this.next();\n          return this.finishNode(node, \"ExistsTypeAnnotation\");\n\n        case tt._typeof:\n          return this.flowParseTypeofType();\n\n        default:\n          if (tokenIsKeyword(this.state.type)) {\n            const label = tokenLabelName(this.state.type);\n            this.next();\n            return super.createIdentifier(node as Undone<N.Identifier>, label);\n          } else if (tokenIsIdentifier(this.state.type)) {\n            if (this.isContextual(tt._interface)) {\n              return this.flowParseInterfaceType();\n            }\n\n            return this.flowIdentToTypeAnnotation(\n              startLoc,\n              node,\n              this.parseIdentifier(),\n            );\n          }\n      }\n\n      this.unexpected();\n    }\n\n    flowParsePostfixType(): N.FlowTypeAnnotation {\n      const startLoc = this.state.startLoc;\n      let type = this.flowParsePrimaryType();\n      let seenOptionalIndexedAccess = false;\n      while (\n        (this.match(tt.bracketL) || this.match(tt.questionDot)) &&\n        !this.canInsertSemicolon()\n      ) {\n        const node = this.startNodeAt(startLoc);\n        const optional = this.eat(tt.questionDot);\n        seenOptionalIndexedAccess = seenOptionalIndexedAccess || optional;\n        this.expect(tt.bracketL);\n        if (!optional && this.match(tt.bracketR)) {\n          node.elementType = type;\n          this.next(); // eat `]`\n          type = this.finishNode(node, \"ArrayTypeAnnotation\");\n        } else {\n          node.objectType = type;\n          node.indexType = this.flowParseType();\n          this.expect(tt.bracketR);\n          if (seenOptionalIndexedAccess) {\n            node.optional = optional;\n            type = this.finishNode<N.FlowOptionalIndexedAccessType>(\n              // @ts-expect-error todo(flow->ts)\n              node,\n              \"OptionalIndexedAccessType\",\n            );\n          } else {\n            type = this.finishNode<N.FlowIndexedAccessType>(\n              // @ts-expect-error todo(flow->ts)\n              node,\n              \"IndexedAccessType\",\n            );\n          }\n        }\n      }\n      return type;\n    }\n\n    flowParsePrefixType(): N.FlowTypeAnnotation {\n      const node = this.startNode();\n      if (this.eat(tt.question)) {\n        node.typeAnnotation = this.flowParsePrefixType();\n        return this.finishNode(node, \"NullableTypeAnnotation\");\n      } else {\n        return this.flowParsePostfixType();\n      }\n    }\n\n    flowParseAnonFunctionWithoutParens(): N.FlowTypeAnnotation {\n      const param = this.flowParsePrefixType();\n      if (!this.state.noAnonFunctionType && this.eat(tt.arrow)) {\n        // TODO: This should be a type error. Passing in a SourceLocation, and it expects a Position.\n        const node = this.startNodeAt(param.loc.start);\n        node.params = [this.reinterpretTypeAsFunctionTypeParam(param)];\n        node.rest = null;\n        node.this = null;\n        node.returnType = this.flowParseType();\n        node.typeParameters = null;\n        return this.finishNode(node, \"FunctionTypeAnnotation\");\n      }\n      return param;\n    }\n\n    flowParseIntersectionType(): N.FlowTypeAnnotation {\n      const node = this.startNode();\n      this.eat(tt.bitwiseAND);\n      const type = this.flowParseAnonFunctionWithoutParens();\n      node.types = [type];\n      while (this.eat(tt.bitwiseAND)) {\n        node.types.push(this.flowParseAnonFunctionWithoutParens());\n      }\n      return node.types.length === 1\n        ? type\n        : this.finishNode(node, \"IntersectionTypeAnnotation\");\n    }\n\n    flowParseUnionType(): N.FlowTypeAnnotation {\n      const node = this.startNode();\n      this.eat(tt.bitwiseOR);\n      const type = this.flowParseIntersectionType();\n      node.types = [type];\n      while (this.eat(tt.bitwiseOR)) {\n        node.types.push(this.flowParseIntersectionType());\n      }\n      return node.types.length === 1\n        ? type\n        : this.finishNode(node, \"UnionTypeAnnotation\");\n    }\n\n    flowParseType(): N.FlowTypeAnnotation {\n      const oldInType = this.state.inType;\n      this.state.inType = true;\n      const type = this.flowParseUnionType();\n      this.state.inType = oldInType;\n      return type;\n    }\n\n    flowParseTypeOrImplicitInstantiation(): N.FlowTypeAnnotation {\n      if (this.state.type === tt.name && this.state.value === \"_\") {\n        const startLoc = this.state.startLoc;\n        const node = this.parseIdentifier();\n        return this.flowParseGenericType(startLoc, node);\n      } else {\n        return this.flowParseType();\n      }\n    }\n\n    flowParseTypeAnnotation(): N.FlowTypeAnnotation {\n      const node = this.startNode<N.FlowTypeAnnotation>();\n      node.typeAnnotation = this.flowParseTypeInitialiser();\n      return this.finishNode(node, \"TypeAnnotation\");\n    }\n\n    flowParseTypeAnnotatableIdentifier(\n      allowPrimitiveOverride?: boolean,\n    ): N.Identifier {\n      const ident = allowPrimitiveOverride\n        ? this.parseIdentifier()\n        : this.flowParseRestrictedIdentifier();\n      if (this.match(tt.colon)) {\n        // @ts-expect-error: refine typings\n        ident.typeAnnotation = this.flowParseTypeAnnotation();\n        this.resetEndLocation(ident);\n      }\n      return ident;\n    }\n\n    typeCastToParameter(node: N.Node): N.Node {\n      node.expression.typeAnnotation = node.typeAnnotation;\n\n      this.resetEndLocation(node.expression, node.typeAnnotation.loc.end);\n\n      return node.expression;\n    }\n\n    flowParseVariance(): N.FlowVariance | undefined | null {\n      let variance = null;\n      if (this.match(tt.plusMin)) {\n        variance = this.startNode<N.FlowVariance>();\n        if (this.state.value === \"+\") {\n          variance.kind = \"plus\";\n        } else {\n          variance.kind = \"minus\";\n        }\n        this.next();\n        return this.finishNode(variance, \"Variance\");\n      }\n      return variance;\n    }\n\n    // ==================================\n    // Overrides\n    // ==================================\n\n    parseFunctionBody(\n      node: N.Function,\n      allowExpressionBody?: boolean | null,\n      isMethod: boolean = false,\n    ): void {\n      if (allowExpressionBody) {\n        this.forwardNoArrowParamsConversionAt(node, () =>\n          super.parseFunctionBody(node, true, isMethod),\n        );\n        return;\n      }\n\n      super.parseFunctionBody(node, false, isMethod);\n    }\n\n    parseFunctionBodyAndFinish<\n      T extends\n        | N.Function\n        | N.TSDeclareMethod\n        | N.TSDeclareFunction\n        | N.ClassPrivateMethod,\n    >(node: Undone<T>, type: T[\"type\"], isMethod: boolean = false): T {\n      if (this.match(tt.colon)) {\n        const typeNode = this.startNode<N.TypeAnnotation>();\n\n        [\n          typeNode.typeAnnotation,\n          // @ts-expect-error predicate may not exist\n          node.predicate,\n        ] = this.flowParseTypeAndPredicateInitialiser();\n\n        node.returnType = typeNode.typeAnnotation\n          ? this.finishNode(typeNode, \"TypeAnnotation\")\n          : null;\n      }\n\n      return super.parseFunctionBodyAndFinish(node, type, isMethod);\n    }\n\n    // interfaces and enums\n    parseStatementLike(flags: ParseStatementFlag): N.Statement {\n      // strict mode handling of `interface` since it's a reserved word\n      if (this.state.strict && this.isContextual(tt._interface)) {\n        const lookahead = this.lookahead();\n        if (tokenIsKeywordOrIdentifier(lookahead.type)) {\n          const node = this.startNode<N.FlowInterface>();\n          this.next();\n          return this.flowParseInterface(node);\n        }\n      } else if (this.shouldParseEnums() && this.isContextual(tt._enum)) {\n        const node = this.startNode();\n        this.next();\n        return this.flowParseEnumDeclaration(node);\n      }\n      const stmt = super.parseStatementLike(flags);\n      // We will parse a flow pragma in any comment before the first statement.\n      if (this.flowPragma === undefined && !this.isValidDirective(stmt)) {\n        this.flowPragma = null;\n      }\n      return stmt;\n    }\n\n    // declares, interfaces and type aliases\n    parseExpressionStatement(\n      node: N.ExpressionStatement,\n      expr: N.Expression,\n      decorators: N.Decorator[] | null,\n    ): N.ExpressionStatement {\n      if (expr.type === \"Identifier\") {\n        if (expr.name === \"declare\") {\n          if (\n            this.match(tt._class) ||\n            tokenIsIdentifier(this.state.type) ||\n            this.match(tt._function) ||\n            this.match(tt._var) ||\n            this.match(tt._export)\n          ) {\n            // @ts-expect-error: refine typings\n            return this.flowParseDeclare(node);\n          }\n        } else if (tokenIsIdentifier(this.state.type)) {\n          if (expr.name === \"interface\") {\n            // @ts-expect-error: refine typings\n            return this.flowParseInterface(node);\n          } else if (expr.name === \"type\") {\n            // @ts-expect-error: refine typings\n            return this.flowParseTypeAlias(node);\n          } else if (expr.name === \"opaque\") {\n            // @ts-expect-error: refine typings\n            return this.flowParseOpaqueType(node, false);\n          }\n        }\n      }\n\n      return super.parseExpressionStatement(node, expr, decorators);\n    }\n\n    // export type\n    shouldParseExportDeclaration(): boolean {\n      const { type } = this.state;\n      if (\n        tokenIsFlowInterfaceOrTypeOrOpaque(type) ||\n        (this.shouldParseEnums() && type === tt._enum)\n      ) {\n        return !this.state.containsEsc;\n      }\n      return super.shouldParseExportDeclaration();\n    }\n\n    isExportDefaultSpecifier(): boolean {\n      const { type } = this.state;\n      if (\n        tokenIsFlowInterfaceOrTypeOrOpaque(type) ||\n        (this.shouldParseEnums() && type === tt._enum)\n      ) {\n        return this.state.containsEsc;\n      }\n\n      return super.isExportDefaultSpecifier();\n    }\n\n    parseExportDefaultExpression(): N.Expression | N.Declaration {\n      if (this.shouldParseEnums() && this.isContextual(tt._enum)) {\n        const node = this.startNode();\n        this.next();\n        return this.flowParseEnumDeclaration(node);\n      }\n      return super.parseExportDefaultExpression();\n    }\n\n    parseConditional(\n      expr: N.Expression,\n\n      startLoc: Position,\n      refExpressionErrors?: ExpressionErrors | null,\n    ): N.Expression {\n      if (!this.match(tt.question)) return expr;\n\n      if (this.state.maybeInArrowParameters) {\n        const nextCh = this.lookaheadCharCode();\n        // These tokens cannot start an expression, so if one of them follows\n        // ? then we are probably in an arrow function parameters list and we\n        // don't parse the conditional expression.\n        if (\n          nextCh === charCodes.comma || // (a?, b) => c\n          nextCh === charCodes.equalsTo || // (a? = b) => c\n          nextCh === charCodes.colon || // (a?: b) => c\n          nextCh === charCodes.rightParenthesis // (a?) => c\n        ) {\n          /*:: invariant(refExpressionErrors != null) */\n          this.setOptionalParametersError(refExpressionErrors);\n          return expr;\n        }\n      }\n\n      this.expect(tt.question);\n      const state = this.state.clone();\n      const originalNoArrowAt = this.state.noArrowAt;\n      const node = this.startNodeAt(startLoc);\n      let { consequent, failed } = this.tryParseConditionalConsequent();\n      let [valid, invalid] = this.getArrowLikeExpressions(consequent);\n\n      if (failed || invalid.length > 0) {\n        const noArrowAt = [...originalNoArrowAt];\n\n        if (invalid.length > 0) {\n          this.state = state;\n          this.state.noArrowAt = noArrowAt;\n\n          for (let i = 0; i < invalid.length; i++) {\n            noArrowAt.push(invalid[i].start);\n          }\n\n          ({ consequent, failed } = this.tryParseConditionalConsequent());\n          [valid, invalid] = this.getArrowLikeExpressions(consequent);\n        }\n\n        if (failed && valid.length > 1) {\n          // if there are two or more possible correct ways of parsing, throw an\n          // error.\n          // e.g.   Source: a ? (b): c => (d): e => f\n          //      Result 1: a ? b : (c => ((d): e => f))\n          //      Result 2: a ? ((b): c => d) : (e => f)\n          this.raise(FlowErrors.AmbiguousConditionalArrow, {\n            at: state.startLoc,\n          });\n        }\n\n        if (failed && valid.length === 1) {\n          this.state = state;\n          noArrowAt.push(valid[0].start);\n          this.state.noArrowAt = noArrowAt;\n          ({ consequent, failed } = this.tryParseConditionalConsequent());\n        }\n      }\n\n      this.getArrowLikeExpressions(consequent, true);\n\n      this.state.noArrowAt = originalNoArrowAt;\n      this.expect(tt.colon);\n\n      node.test = expr;\n      node.consequent = consequent;\n      node.alternate = this.forwardNoArrowParamsConversionAt(node, () =>\n        this.parseMaybeAssign(undefined, undefined),\n      );\n\n      return this.finishNode(node, \"ConditionalExpression\");\n    }\n\n    tryParseConditionalConsequent(): {\n      consequent: N.Expression;\n      failed: boolean;\n    } {\n      this.state.noArrowParamsConversionAt.push(this.state.start);\n\n      const consequent = this.parseMaybeAssignAllowIn();\n      const failed = !this.match(tt.colon);\n\n      this.state.noArrowParamsConversionAt.pop();\n\n      return { consequent, failed };\n    }\n\n    // Given an expression, walks through out its arrow functions whose body is\n    // an expression and through out conditional expressions. It returns every\n    // function which has been parsed with a return type but could have been\n    // parenthesized expressions.\n    // These functions are separated into two arrays: one containing the ones\n    // whose parameters can be converted to assignable lists, one containing the\n    // others.\n    getArrowLikeExpressions(\n      node: N.Expression,\n      disallowInvalid?: boolean,\n    ): [N.ArrowFunctionExpression[], N.ArrowFunctionExpression[]] {\n      const stack = [node];\n      const arrows: N.ArrowFunctionExpression[] = [];\n\n      while (stack.length !== 0) {\n        const node = stack.pop();\n        if (node.type === \"ArrowFunctionExpression\") {\n          if (node.typeParameters || !node.returnType) {\n            // This is an arrow expression without ambiguity, so check its parameters\n            // @ts-expect-error: refine typings\n            this.finishArrowValidation(node);\n          } else {\n            // @ts-expect-error: refine typings\n            arrows.push(node);\n          }\n          stack.push(node.body);\n        } else if (node.type === \"ConditionalExpression\") {\n          stack.push(node.consequent);\n          stack.push(node.alternate);\n        }\n      }\n\n      if (disallowInvalid) {\n        arrows.forEach(node => this.finishArrowValidation(node));\n        return [arrows, []];\n      }\n\n      return partition(arrows, node =>\n        node.params.every(param => this.isAssignable(param, true)),\n      );\n    }\n\n    finishArrowValidation(node: N.ArrowFunctionExpression) {\n      this.toAssignableList(\n        // node.params is Expression[] instead of $ReadOnlyArray<Pattern> because it\n        // has not been converted yet.\n        node.params as any as N.Expression[],\n        node.extra?.trailingCommaLoc,\n        /* isLHS */ false,\n      );\n      // Enter scope, as checkParams defines bindings\n      this.scope.enter(SCOPE_FUNCTION | SCOPE_ARROW);\n      // Use super's method to force the parameters to be checked\n      super.checkParams(node, false, true);\n      this.scope.exit();\n    }\n\n    forwardNoArrowParamsConversionAt<T>(\n      node: Undone<N.Node>,\n      parse: () => T,\n    ): T {\n      let result: T;\n      if (this.state.noArrowParamsConversionAt.indexOf(node.start) !== -1) {\n        this.state.noArrowParamsConversionAt.push(this.state.start);\n        result = parse();\n        this.state.noArrowParamsConversionAt.pop();\n      } else {\n        result = parse();\n      }\n\n      return result;\n    }\n\n    parseParenItem(\n      node: N.Expression,\n\n      startLoc: Position,\n    ): N.Expression {\n      node = super.parseParenItem(node, startLoc);\n      if (this.eat(tt.question)) {\n        node.optional = true;\n        // Include questionmark in location of node\n        // Don't use this.finishNode() as otherwise we might process comments twice and\n        // include already consumed parens\n        this.resetEndLocation(node);\n      }\n\n      if (this.match(tt.colon)) {\n        const typeCastNode = this.startNodeAt(startLoc);\n        typeCastNode.expression = node;\n        typeCastNode.typeAnnotation = this.flowParseTypeAnnotation();\n\n        return this.finishNode(typeCastNode, \"TypeCastExpression\");\n      }\n\n      return node;\n    }\n\n    assertModuleNodeAllowed(node: N.Node) {\n      if (\n        (node.type === \"ImportDeclaration\" &&\n          (node.importKind === \"type\" || node.importKind === \"typeof\")) ||\n        (node.type === \"ExportNamedDeclaration\" &&\n          node.exportKind === \"type\") ||\n        (node.type === \"ExportAllDeclaration\" && node.exportKind === \"type\")\n      ) {\n        // Allow Flowtype imports and exports in all conditions because\n        // Flow itself does not care about 'sourceType'.\n        return;\n      }\n\n      super.assertModuleNodeAllowed(node);\n    }\n\n    parseExportDeclaration(\n      node: N.ExportNamedDeclaration,\n    ): N.Declaration | undefined | null {\n      if (this.isContextual(tt._type)) {\n        node.exportKind = \"type\";\n\n        const declarationNode = this.startNode();\n        this.next();\n\n        if (this.match(tt.braceL)) {\n          // export type { foo, bar };\n          node.specifiers = this.parseExportSpecifiers(\n            /* isInTypeExport */ true,\n          );\n          super.parseExportFrom(node);\n          return null;\n        } else {\n          // export type Foo = Bar;\n          // @ts-expect-error: refine typings\n          return this.flowParseTypeAlias(declarationNode);\n        }\n      } else if (this.isContextual(tt._opaque)) {\n        node.exportKind = \"type\";\n\n        const declarationNode = this.startNode();\n        this.next();\n        // export opaque type Foo = Bar;\n        // @ts-expect-error: refine typings\n        return this.flowParseOpaqueType(declarationNode, false);\n      } else if (this.isContextual(tt._interface)) {\n        node.exportKind = \"type\";\n        const declarationNode = this.startNode();\n        this.next();\n        // @ts-expect-error: refine typings\n        return this.flowParseInterface(declarationNode);\n      } else if (this.shouldParseEnums() && this.isContextual(tt._enum)) {\n        node.exportKind = \"value\";\n        const declarationNode = this.startNode();\n        this.next();\n        // @ts-expect-error: refine typings\n        return this.flowParseEnumDeclaration(declarationNode);\n      } else {\n        return super.parseExportDeclaration(node);\n      }\n    }\n\n    eatExportStar(node: N.Node): boolean {\n      if (super.eatExportStar(node)) return true;\n\n      if (this.isContextual(tt._type) && this.lookahead().type === tt.star) {\n        node.exportKind = \"type\";\n        this.next();\n        this.next();\n        return true;\n      }\n\n      return false;\n    }\n\n    maybeParseExportNamespaceSpecifier(node: N.Node): boolean {\n      const { startLoc } = this.state;\n      const hasNamespace = super.maybeParseExportNamespaceSpecifier(node);\n      if (hasNamespace && node.exportKind === \"type\") {\n        this.unexpected(startLoc);\n      }\n      return hasNamespace;\n    }\n\n    parseClassId(\n      node: N.Class,\n      isStatement: boolean,\n      optionalId?: boolean | null,\n    ) {\n      super.parseClassId(node, isStatement, optionalId);\n      if (this.match(tt.lt)) {\n        node.typeParameters = this.flowParseTypeParameterDeclaration();\n      }\n    }\n\n    parseClassMember(\n      classBody: N.ClassBody,\n      member: any,\n      state: N.ParseClassMemberState,\n    ): void {\n      const { startLoc } = this.state;\n      if (this.isContextual(tt._declare)) {\n        if (super.parseClassMemberFromModifier(classBody, member)) {\n          // 'declare' is a class element name\n          return;\n        }\n\n        member.declare = true;\n      }\n\n      super.parseClassMember(classBody, member, state);\n\n      if (member.declare) {\n        if (\n          member.type !== \"ClassProperty\" &&\n          member.type !== \"ClassPrivateProperty\" &&\n          member.type !== \"PropertyDefinition\" // Used by estree plugin\n        ) {\n          this.raise(FlowErrors.DeclareClassElement, { at: startLoc });\n        } else if (member.value) {\n          this.raise(FlowErrors.DeclareClassFieldInitializer, {\n            at: member.value,\n          });\n        }\n      }\n    }\n\n    isIterator(word: string): boolean {\n      return word === \"iterator\" || word === \"asyncIterator\";\n    }\n\n    readIterator(): void {\n      const word = super.readWord1();\n      const fullWord = \"@@\" + word;\n\n      // Allow @@iterator and @@asyncIterator as a identifier only inside type\n      if (!this.isIterator(word) || !this.state.inType) {\n        this.raise(Errors.InvalidIdentifier, {\n          at: this.state.curPosition(),\n          identifierName: fullWord,\n        });\n      }\n\n      this.finishToken(tt.name, fullWord);\n    }\n\n    // ensure that inside flow types, we bypass the jsx parser plugin\n    getTokenFromCode(code: number): void {\n      const next = this.input.charCodeAt(this.state.pos + 1);\n      if (code === charCodes.leftCurlyBrace && next === charCodes.verticalBar) {\n        this.finishOp(tt.braceBarL, 2);\n      } else if (\n        this.state.inType &&\n        (code === charCodes.greaterThan || code === charCodes.lessThan)\n      ) {\n        this.finishOp(code === charCodes.greaterThan ? tt.gt : tt.lt, 1);\n      } else if (this.state.inType && code === charCodes.questionMark) {\n        if (next === charCodes.dot) {\n          this.finishOp(tt.questionDot, 2);\n        } else {\n          // allow double nullable types in Flow: ??string\n          this.finishOp(tt.question, 1);\n        }\n      } else if (\n        isIteratorStart(code, next, this.input.charCodeAt(this.state.pos + 2))\n      ) {\n        this.state.pos += 2; // eat \"@@\"\n        this.readIterator();\n      } else {\n        super.getTokenFromCode(code);\n      }\n    }\n\n    isAssignable(node: N.Node, isBinding?: boolean): boolean {\n      if (node.type === \"TypeCastExpression\") {\n        return this.isAssignable(node.expression, isBinding);\n      } else {\n        return super.isAssignable(node, isBinding);\n      }\n    }\n\n    toAssignable(node: N.Node, isLHS: boolean = false): void {\n      if (\n        !isLHS &&\n        node.type === \"AssignmentExpression\" &&\n        node.left.type === \"TypeCastExpression\"\n      ) {\n        node.left = this.typeCastToParameter(node.left);\n      }\n      super.toAssignable(node, isLHS);\n    }\n\n    // turn type casts that we found in function parameter head into type annotated params\n    toAssignableList(\n      exprList: N.Expression[],\n      trailingCommaLoc: Position | undefined | null,\n      isLHS: boolean,\n    ): void {\n      for (let i = 0; i < exprList.length; i++) {\n        const expr = exprList[i];\n        if (expr?.type === \"TypeCastExpression\") {\n          exprList[i] = this.typeCastToParameter(expr);\n        }\n      }\n      super.toAssignableList(exprList, trailingCommaLoc, isLHS);\n    }\n\n    // this is a list of nodes, from something like a call expression, we need to filter the\n    // type casts that we've found that are illegal in this context\n    toReferencedList(\n      exprList: ReadonlyArray<N.Expression | undefined | null>,\n      isParenthesizedExpr?: boolean,\n    ): ReadonlyArray<N.Expression | undefined | null> {\n      for (let i = 0; i < exprList.length; i++) {\n        const expr = exprList[i];\n        if (\n          expr &&\n          expr.type === \"TypeCastExpression\" &&\n          !expr.extra?.parenthesized &&\n          (exprList.length > 1 || !isParenthesizedExpr)\n        ) {\n          this.raise(FlowErrors.TypeCastInPattern, {\n            at: expr.typeAnnotation,\n          });\n        }\n      }\n\n      return exprList;\n    }\n\n    parseArrayLike(\n      close: TokenType,\n      canBePattern: boolean,\n      isTuple: boolean,\n      refExpressionErrors?: ExpressionErrors | null,\n    ): N.ArrayExpression | N.TupleExpression {\n      const node = super.parseArrayLike(\n        close,\n        canBePattern,\n        isTuple,\n        refExpressionErrors,\n      );\n\n      // This could be an array pattern:\n      //   ([a: string, b: string]) => {}\n      // In this case, we don't have to call toReferencedList. We will\n      // call it, if needed, when we are sure that it is a parenthesized\n      // expression by calling toReferencedListDeep.\n      if (canBePattern && !this.state.maybeInArrowParameters) {\n        this.toReferencedList(node.elements);\n      }\n\n      return node;\n    }\n\n    isValidLVal(type: string, isParenthesized: boolean, binding: BindingTypes) {\n      return (\n        type === \"TypeCastExpression\" ||\n        super.isValidLVal(type, isParenthesized, binding)\n      );\n    }\n\n    // parse class property type annotations\n    parseClassProperty(node: N.ClassProperty): N.ClassProperty {\n      if (this.match(tt.colon)) {\n        // @ts-expect-error refine typings\n        node.typeAnnotation = this.flowParseTypeAnnotation();\n      }\n      return super.parseClassProperty(node);\n    }\n\n    parseClassPrivateProperty(\n      node: N.ClassPrivateProperty,\n    ): N.ClassPrivateProperty {\n      if (this.match(tt.colon)) {\n        // @ts-expect-error refine typings\n        node.typeAnnotation = this.flowParseTypeAnnotation();\n      }\n      return super.parseClassPrivateProperty(node);\n    }\n\n    // determine whether or not we're currently in the position where a class method would appear\n    isClassMethod(): boolean {\n      return this.match(tt.lt) || super.isClassMethod();\n    }\n\n    // determine whether or not we're currently in the position where a class property would appear\n    isClassProperty(): boolean {\n      return this.match(tt.colon) || super.isClassProperty();\n    }\n\n    isNonstaticConstructor(method: N.ClassMethod | N.ClassProperty): boolean {\n      return !this.match(tt.colon) && super.isNonstaticConstructor(method);\n    }\n\n    // parse type parameters for class methods\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      if ((method as any).variance) {\n        this.unexpected((method as any).variance.loc.start);\n      }\n      delete (method as any).variance;\n      if (this.match(tt.lt)) {\n        method.typeParameters = this.flowParseTypeParameterDeclaration();\n      }\n\n      super.pushClassMethod(\n        classBody,\n        method,\n        isGenerator,\n        isAsync,\n        isConstructor,\n        allowsDirectSuper,\n      );\n\n      if (method.params && isConstructor) {\n        const params = method.params;\n        if (params.length > 0 && this.isThisParam(params[0])) {\n          this.raise(FlowErrors.ThisParamBannedInConstructor, { at: method });\n        }\n        // estree support\n      } else if (\n        // @ts-expect-error TS does not know about the face that estree can replace ClassMethod with MethodDefinition\n        method.type === \"MethodDefinition\" &&\n        isConstructor &&\n        // @ts-expect-error estree\n        method.value.params\n      ) {\n        // @ts-expect-error estree\n        const params = method.value.params;\n        if (params.length > 0 && this.isThisParam(params[0])) {\n          this.raise(FlowErrors.ThisParamBannedInConstructor, { at: method });\n        }\n      }\n    }\n\n    pushClassPrivateMethod(\n      classBody: N.ClassBody,\n      method: N.ClassPrivateMethod,\n      isGenerator: boolean,\n      isAsync: boolean,\n    ): void {\n      if ((method as any).variance) {\n        this.unexpected((method as any).variance.loc.start);\n      }\n      delete (method as any).variance;\n      if (this.match(tt.lt)) {\n        method.typeParameters = this.flowParseTypeParameterDeclaration();\n      }\n\n      super.pushClassPrivateMethod(classBody, method, isGenerator, isAsync);\n    }\n\n    // parse a the super class type parameters and implements\n    parseClassSuper(node: N.Class): void {\n      super.parseClassSuper(node);\n      if (node.superClass && this.match(tt.lt)) {\n        node.superTypeParameters = this.flowParseTypeParameterInstantiation();\n      }\n      if (this.isContextual(tt._implements)) {\n        this.next();\n        const implemented: N.FlowClassImplements[] = (node.implements = []);\n        do {\n          const node = this.startNode();\n          node.id = this.flowParseRestrictedIdentifier(/*liberal*/ true);\n          if (this.match(tt.lt)) {\n            node.typeParameters = this.flowParseTypeParameterInstantiation();\n          } else {\n            node.typeParameters = null;\n          }\n          implemented.push(this.finishNode(node, \"ClassImplements\"));\n        } while (this.eat(tt.comma));\n      }\n    }\n\n    checkGetterSetterParams(method: N.ObjectMethod | N.ClassMethod): void {\n      super.checkGetterSetterParams(method);\n      const params = this.getObjectOrClassMethodParams(method);\n      if (params.length > 0) {\n        const param = params[0];\n        if (this.isThisParam(param) && method.kind === \"get\") {\n          this.raise(FlowErrors.GetterMayNotHaveThisParam, { at: param });\n        } else if (this.isThisParam(param)) {\n          this.raise(FlowErrors.SetterMayNotHaveThisParam, { at: param });\n        }\n      }\n    }\n\n    parsePropertyNamePrefixOperator(\n      node: N.ObjectOrClassMember | N.ClassMember,\n    ): void {\n      node.variance = this.flowParseVariance();\n    }\n\n    // parse type parameters for object method shorthand\n    parseObjPropValue(\n      prop: Undone<N.ObjectMethod | N.ObjectProperty>,\n      startLoc: Position | undefined | null,\n      isGenerator: boolean,\n      isAsync: boolean,\n      isPattern: boolean,\n      isAccessor: boolean,\n      refExpressionErrors?: ExpressionErrors | null,\n    ): N.ObjectMethod | N.ObjectProperty {\n      if ((prop as any).variance) {\n        this.unexpected((prop as any).variance.loc.start);\n      }\n      delete (prop as any).variance;\n\n      let typeParameters;\n\n      // method shorthand\n      if (this.match(tt.lt) && !isAccessor) {\n        typeParameters = this.flowParseTypeParameterDeclaration();\n        if (!this.match(tt.parenL)) this.unexpected();\n      }\n\n      const result = super.parseObjPropValue(\n        prop,\n        startLoc,\n        isGenerator,\n        isAsync,\n        isPattern,\n        isAccessor,\n        refExpressionErrors,\n      );\n\n      // add typeParameters if we found them\n      if (typeParameters) {\n        (result.value || result).typeParameters = typeParameters;\n      }\n      return result;\n    }\n\n    parseAssignableListItemTypes(param: N.Pattern): N.Pattern {\n      if (this.eat(tt.question)) {\n        if (param.type !== \"Identifier\") {\n          this.raise(FlowErrors.PatternIsOptional, { at: param });\n        }\n        if (this.isThisParam(param)) {\n          this.raise(FlowErrors.ThisParamMayNotBeOptional, { at: param });\n        }\n\n        (param as any as N.Identifier).optional = true;\n      }\n      if (this.match(tt.colon)) {\n        // @ts-expect-error: refine typings\n        param.typeAnnotation = this.flowParseTypeAnnotation();\n      } else if (this.isThisParam(param)) {\n        this.raise(FlowErrors.ThisParamAnnotationRequired, { at: param });\n      }\n\n      if (this.match(tt.eq) && this.isThisParam(param)) {\n        this.raise(FlowErrors.ThisParamNoDefault, { at: param });\n      }\n\n      this.resetEndLocation(param);\n      return param;\n    }\n\n    parseMaybeDefault(\n      startLoc?: Position | null,\n      left?: N.Pattern | null,\n    ): N.Pattern {\n      const node = super.parseMaybeDefault(startLoc, left);\n\n      if (\n        node.type === \"AssignmentPattern\" &&\n        node.typeAnnotation &&\n        node.right.start < node.typeAnnotation.start\n      ) {\n        this.raise(FlowErrors.TypeBeforeInitializer, {\n          at: node.typeAnnotation,\n        });\n      }\n\n      return node;\n    }\n\n    checkImportReflection(node: Undone<N.ImportDeclaration>) {\n      super.checkImportReflection(node);\n      if (node.module && node.importKind !== \"value\") {\n        this.raise(FlowErrors.ImportReflectionHasImportType, {\n          at: node.specifiers[0].loc.start,\n        });\n      }\n    }\n\n    parseImportSpecifierLocal<\n      T extends\n        | N.ImportSpecifier\n        | N.ImportDefaultSpecifier\n        | N.ImportNamespaceSpecifier,\n    >(node: N.ImportDeclaration, specifier: Undone<T>, type: T[\"type\"]): void {\n      specifier.local = hasTypeImportKind(node)\n        ? this.flowParseRestrictedIdentifier(\n            /* liberal */ true,\n            /* declaration */ true,\n          )\n        : this.parseIdentifier();\n\n      node.specifiers.push(this.finishImportSpecifier(specifier, type));\n    }\n\n    isPotentialImportPhase(isExport: boolean): boolean {\n      if (super.isPotentialImportPhase(isExport)) return true;\n      if (this.isContextual(tt._type)) {\n        if (!isExport) return true;\n        const ch = this.lookaheadCharCode();\n        return ch === charCodes.leftCurlyBrace || ch === charCodes.asterisk;\n      }\n      return !isExport && this.isContextual(tt._typeof);\n    }\n\n    applyImportPhase(\n      node: Undone<N.ImportDeclaration | N.ExportNamedDeclaration>,\n      isExport: boolean,\n      phase: string | null,\n      loc?: Position,\n    ): void {\n      super.applyImportPhase(node, isExport, phase, loc);\n      if (isExport) {\n        if (!phase && this.match(tt._default)) {\n          // TODO: Align with our TS AST and always add .exportKind\n          return;\n        }\n        (node as N.ExportNamedDeclaration).exportKind =\n          phase === \"type\" ? phase : \"value\";\n      } else {\n        if (phase === \"type\" && this.match(tt.star)) this.unexpected();\n        (node as N.ImportDeclaration).importKind =\n          phase === \"type\" || phase === \"typeof\" ? phase : \"value\";\n      }\n    }\n\n    // parse import-type/typeof shorthand\n    parseImportSpecifier(\n      specifier: any,\n      importedIsString: boolean,\n      isInTypeOnlyImport: boolean,\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n      isMaybeTypeOnly: boolean,\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n      bindingType: BindingTypes | undefined,\n    ): N.ImportSpecifier {\n      const firstIdent = specifier.imported;\n\n      let specifierTypeKind = null;\n      if (firstIdent.type === \"Identifier\") {\n        if (firstIdent.name === \"type\") {\n          specifierTypeKind = \"type\";\n        } else if (firstIdent.name === \"typeof\") {\n          specifierTypeKind = \"typeof\";\n        }\n      }\n\n      let isBinding = false;\n      if (this.isContextual(tt._as) && !this.isLookaheadContextual(\"as\")) {\n        const as_ident = this.parseIdentifier(true);\n        if (\n          specifierTypeKind !== null &&\n          !tokenIsKeywordOrIdentifier(this.state.type)\n        ) {\n          // `import {type as ,` or `import {type as }`\n          specifier.imported = as_ident;\n          specifier.importKind = specifierTypeKind;\n          specifier.local = cloneIdentifier(as_ident);\n        } else {\n          // `import {type as foo`\n          specifier.imported = firstIdent;\n          specifier.importKind = null;\n          specifier.local = this.parseIdentifier();\n        }\n      } else {\n        if (\n          specifierTypeKind !== null &&\n          tokenIsKeywordOrIdentifier(this.state.type)\n        ) {\n          // `import {type foo`\n          specifier.imported = this.parseIdentifier(true);\n          specifier.importKind = specifierTypeKind;\n        } else {\n          if (importedIsString) {\n            /*:: invariant(firstIdent instanceof N.StringLiteral) */\n            throw this.raise(Errors.ImportBindingIsString, {\n              at: specifier,\n              importName: firstIdent.value,\n            });\n          }\n          /*:: invariant(firstIdent instanceof N.Node) */\n          specifier.imported = firstIdent;\n          specifier.importKind = null;\n        }\n\n        if (this.eatContextual(tt._as)) {\n          specifier.local = this.parseIdentifier();\n        } else {\n          isBinding = true;\n          specifier.local = cloneIdentifier(specifier.imported);\n        }\n      }\n\n      const specifierIsTypeImport = hasTypeImportKind(specifier);\n\n      if (isInTypeOnlyImport && specifierIsTypeImport) {\n        this.raise(FlowErrors.ImportTypeShorthandOnlyInPureImport, {\n          at: specifier,\n        });\n      }\n\n      if (isInTypeOnlyImport || specifierIsTypeImport) {\n        this.checkReservedType(\n          specifier.local.name,\n          specifier.local.loc.start,\n          /* declaration */ true,\n        );\n      }\n\n      if (isBinding && !isInTypeOnlyImport && !specifierIsTypeImport) {\n        this.checkReservedWord(\n          specifier.local.name,\n          specifier.loc.start,\n          true,\n          true,\n        );\n      }\n\n      return this.finishImportSpecifier(specifier, \"ImportSpecifier\");\n    }\n\n    parseBindingAtom(): N.Pattern {\n      switch (this.state.type) {\n        case tt._this:\n          // \"this\" may be the name of a parameter, so allow it.\n          return this.parseIdentifier(/* liberal */ true);\n        default:\n          return super.parseBindingAtom();\n      }\n    }\n\n    // parse function type parameters - function foo<T>() {}\n    parseFunctionParams(\n      node: Undone<N.Function>,\n      isConstructor: boolean,\n    ): void {\n      // @ts-expect-error kind may not index node\n      const kind = node.kind;\n      if (kind !== \"get\" && kind !== \"set\" && this.match(tt.lt)) {\n        node.typeParameters = this.flowParseTypeParameterDeclaration();\n      }\n      super.parseFunctionParams(node, isConstructor);\n    }\n\n    // parse flow type annotations on variable declarator heads - let foo: string = bar\n    parseVarId(\n      decl: N.VariableDeclarator,\n      kind: \"var\" | \"let\" | \"const\",\n    ): void {\n      super.parseVarId(decl, kind);\n      if (this.match(tt.colon)) {\n        // @ts-expect-error: refine typings\n        decl.id.typeAnnotation = this.flowParseTypeAnnotation();\n        this.resetEndLocation(decl.id); // set end position to end of type\n      }\n    }\n\n    // parse the return type of an async arrow function - let foo = (async (): number => {});\n    parseAsyncArrowFromCallExpression(\n      node: N.ArrowFunctionExpression,\n      call: N.CallExpression,\n    ): N.ArrowFunctionExpression {\n      if (this.match(tt.colon)) {\n        const oldNoAnonFunctionType = this.state.noAnonFunctionType;\n        this.state.noAnonFunctionType = true;\n        // @ts-expect-error refine typings\n        node.returnType = this.flowParseTypeAnnotation();\n        this.state.noAnonFunctionType = oldNoAnonFunctionType;\n      }\n\n      return super.parseAsyncArrowFromCallExpression(node, call);\n    }\n\n    // todo description\n    shouldParseAsyncArrow(): boolean {\n      return this.match(tt.colon) || super.shouldParseAsyncArrow();\n    }\n\n    // We need to support type parameter declarations for arrow functions. This\n    // is tricky. There are three situations we need to handle\n    //\n    // 1. This is either JSX or an arrow function. We'll try JSX first. If that\n    //    fails, we'll try an arrow function. If that fails, we'll throw the JSX\n    //    error.\n    // 2. This is an arrow function. We'll parse the type parameter declaration,\n    //    parse the rest, make sure the rest is an arrow function, and go from\n    //    there\n    // 3. This is neither. Just call the super method\n    parseMaybeAssign(\n      refExpressionErrors?: ExpressionErrors | null,\n      afterLeftParse?: Function,\n    ): N.Expression {\n      let state = null;\n\n      let jsx;\n\n      if (\n        this.hasPlugin(\"jsx\") &&\n        (this.match(tt.jsxTagStart) || this.match(tt.lt))\n      ) {\n        state = this.state.clone();\n\n        jsx = this.tryParse(\n          () => super.parseMaybeAssign(refExpressionErrors, afterLeftParse),\n          state,\n        );\n\n        /*:: invariant(!jsx.aborted) */\n        /*:: invariant(jsx.node != null) */\n        if (!jsx.error) return jsx.node;\n\n        // Remove `tc.j_expr` and `tc.j_oTag` from context added\n        // by parsing `jsxTagStart` to stop the JSX plugin from\n        // messing with the tokens\n        const { context } = this.state;\n        const currentContext = context[context.length - 1];\n        if (currentContext === tc.j_oTag || currentContext === tc.j_expr) {\n          context.pop();\n        }\n      }\n\n      if (jsx?.error || this.match(tt.lt)) {\n        state = state || this.state.clone();\n\n        let typeParameters: N.TypeParameterDeclaration;\n\n        const arrow = this.tryParse(abort => {\n          typeParameters = this.flowParseTypeParameterDeclaration();\n\n          const arrowExpression = this.forwardNoArrowParamsConversionAt(\n            typeParameters,\n            () => {\n              const result = super.parseMaybeAssign(\n                refExpressionErrors,\n                afterLeftParse,\n              );\n\n              this.resetStartLocationFromNode(result, typeParameters);\n\n              return result;\n            },\n          );\n\n          // <T>(() => {});\n          // <T>(() => {}: any);\n          if (arrowExpression.extra?.parenthesized) abort();\n\n          // The above can return a TypeCastExpression when the arrow\n          // expression is not wrapped in parens. See also `this.parseParenItem`.\n          // (<T>() => {}: any);\n          const expr = this.maybeUnwrapTypeCastExpression(arrowExpression);\n\n          if (expr.type !== \"ArrowFunctionExpression\") abort();\n\n          expr.typeParameters = typeParameters;\n          this.resetStartLocationFromNode(expr, typeParameters);\n\n          return arrowExpression;\n        }, state);\n\n        let arrowExpression:\n          | N.ArrowFunctionExpression\n          | N.TypeCastExpression\n          | undefined\n          | null = null;\n\n        if (\n          arrow.node &&\n          // @ts-expect-error: refine tryParse typings\n          this.maybeUnwrapTypeCastExpression(arrow.node).type ===\n            \"ArrowFunctionExpression\"\n        ) {\n          if (!arrow.error && !arrow.aborted) {\n            // <T> async () => {}\n            // @ts-expect-error: refine tryParse typings\n            if (arrow.node.async) {\n              /*:: invariant(typeParameters) */\n              this.raise(\n                FlowErrors.UnexpectedTypeParameterBeforeAsyncArrowFunction,\n                { at: typeParameters },\n              );\n            }\n            // @ts-expect-error: refine tryParse typings\n            return arrow.node;\n          }\n\n          // @ts-expect-error: refine typings\n          arrowExpression = arrow.node;\n        }\n\n        // If we are here, both JSX and Flow parsing attempts failed.\n        // Give the precedence to the JSX error, except if JSX had an\n        // unrecoverable error while Flow didn't.\n        // If the error is recoverable, we can only re-report it if there is\n        // a node we can return.\n\n        if (jsx?.node) {\n          /*:: invariant(jsx.failState) */\n          this.state = jsx.failState;\n          return jsx.node;\n        }\n\n        if (arrowExpression) {\n          /*:: invariant(arrow.failState) */\n          this.state = arrow.failState;\n          return arrowExpression;\n        }\n\n        if (jsx?.thrown) throw jsx.error;\n        if (arrow.thrown) throw arrow.error;\n\n        /*:: invariant(typeParameters) */\n        throw this.raise(FlowErrors.UnexpectedTokenAfterTypeParameter, {\n          at: typeParameters,\n        });\n      }\n\n      return super.parseMaybeAssign(refExpressionErrors, afterLeftParse);\n    }\n\n    // handle return types for arrow functions\n    parseArrow(\n      node: Undone<N.ArrowFunctionExpression>,\n    ): Undone<N.ArrowFunctionExpression> | undefined | null {\n      if (this.match(tt.colon)) {\n        // @ts-expect-error todo(flow->ts)\n        const result = this.tryParse(() => {\n          const oldNoAnonFunctionType = this.state.noAnonFunctionType;\n          this.state.noAnonFunctionType = true;\n\n          const typeNode = this.startNode<N.TypeAnnotation>();\n\n          [\n            typeNode.typeAnnotation,\n            // @ts-expect-error (destructuring not supported yet)\n            node.predicate,\n          ] = this.flowParseTypeAndPredicateInitialiser();\n\n          this.state.noAnonFunctionType = oldNoAnonFunctionType;\n\n          if (this.canInsertSemicolon()) this.unexpected();\n          if (!this.match(tt.arrow)) this.unexpected();\n\n          return typeNode;\n        });\n\n        if (result.thrown) return null;\n        /*:: invariant(result.node) */\n\n        if (result.error) this.state = result.failState;\n\n        // assign after it is clear it is an arrow\n        // @ts-expect-error todo(flow->ts)\n        node.returnType = result.node.typeAnnotation\n          ? this.finishNode(result.node, \"TypeAnnotation\")\n          : null;\n      }\n\n      return super.parseArrow(node);\n    }\n\n    shouldParseArrow(params: Array<N.Node>): boolean {\n      return this.match(tt.colon) || super.shouldParseArrow(params);\n    }\n\n    setArrowFunctionParameters(\n      node: N.ArrowFunctionExpression,\n      params: N.Pattern[],\n    ): void {\n      if (this.state.noArrowParamsConversionAt.indexOf(node.start) !== -1) {\n        node.params = params;\n      } else {\n        super.setArrowFunctionParameters(node, params);\n      }\n    }\n\n    checkParams(\n      node: N.Function,\n      allowDuplicates: boolean,\n      isArrowFunction?: boolean | null,\n      strictModeChanged: boolean = true,\n    ): void {\n      if (\n        isArrowFunction &&\n        this.state.noArrowParamsConversionAt.indexOf(node.start) !== -1\n      ) {\n        return;\n      }\n\n      // ensure the `this` param is first, if it exists\n      for (let i = 0; i < node.params.length; i++) {\n        if (this.isThisParam(node.params[i]) && i > 0) {\n          this.raise(FlowErrors.ThisParamMustBeFirst, { at: node.params[i] });\n        }\n      }\n\n      super.checkParams(\n        node,\n        allowDuplicates,\n        isArrowFunction,\n        strictModeChanged,\n      );\n    }\n\n    parseParenAndDistinguishExpression(canBeArrow: boolean): N.Expression {\n      return super.parseParenAndDistinguishExpression(\n        canBeArrow && this.state.noArrowAt.indexOf(this.state.start) === -1,\n      );\n    }\n\n    parseSubscripts(\n      base: N.Expression,\n\n      startLoc: Position,\n      noCalls?: boolean | null,\n    ): N.Expression {\n      if (\n        base.type === \"Identifier\" &&\n        base.name === \"async\" &&\n        this.state.noArrowAt.indexOf(startLoc.index) !== -1\n      ) {\n        this.next();\n\n        const node = this.startNodeAt(startLoc);\n        node.callee = base;\n        node.arguments = super.parseCallExpressionArguments(tt.parenR, false);\n        base = this.finishNode(node, \"CallExpression\");\n      } else if (\n        base.type === \"Identifier\" &&\n        base.name === \"async\" &&\n        this.match(tt.lt)\n      ) {\n        const state = this.state.clone();\n        const arrow = this.tryParse(\n          abort => this.parseAsyncArrowWithTypeParameters(startLoc) || abort(),\n          state,\n        );\n\n        /*:: invariant(arrow.node != null) */\n        // @ts-expect-error: refine tryParse typings\n        if (!arrow.error && !arrow.aborted) return arrow.node;\n\n        const result = this.tryParse(\n          () => super.parseSubscripts(base, startLoc, noCalls),\n          state,\n        );\n\n        if (result.node && !result.error) return result.node;\n\n        if (arrow.node) {\n          this.state = arrow.failState;\n          // @ts-expect-error: refine tryParse typings\n          return arrow.node;\n        }\n\n        if (result.node) {\n          this.state = result.failState;\n          return result.node;\n        }\n\n        throw arrow.error || result.error;\n      }\n\n      return super.parseSubscripts(base, startLoc, noCalls);\n    }\n\n    parseSubscript(\n      base: N.Expression,\n\n      startLoc: Position,\n      noCalls: boolean | undefined | null,\n      subscriptState: N.ParseSubscriptState,\n    ): N.Expression {\n      if (this.match(tt.questionDot) && this.isLookaheadToken_lt()) {\n        subscriptState.optionalChainMember = true;\n        if (noCalls) {\n          subscriptState.stop = true;\n          return base;\n        }\n        this.next();\n        const node = this.startNodeAt<N.OptionalCallExpression>(startLoc);\n        node.callee = base;\n        node.typeArguments = this.flowParseTypeParameterInstantiation();\n        this.expect(tt.parenL);\n        node.arguments = this.parseCallExpressionArguments(tt.parenR, false);\n        node.optional = true;\n        return this.finishCallExpression(node, /* optional */ true);\n      } else if (!noCalls && this.shouldParseTypes() && this.match(tt.lt)) {\n        const node = this.startNodeAt<\n          N.OptionalCallExpression | N.CallExpression\n        >(startLoc);\n        node.callee = base;\n\n        const result = this.tryParse(() => {\n          node.typeArguments =\n            this.flowParseTypeParameterInstantiationCallOrNew();\n          this.expect(tt.parenL);\n          node.arguments = super.parseCallExpressionArguments(tt.parenR, false);\n          if (subscriptState.optionalChainMember) {\n            (node as Undone<N.OptionalCallExpression>).optional = false;\n          }\n          return this.finishCallExpression(\n            node,\n            subscriptState.optionalChainMember,\n          );\n        });\n\n        if (result.node) {\n          if (result.error) this.state = result.failState;\n          return result.node;\n        }\n      }\n\n      return super.parseSubscript(\n        base,\n\n        startLoc,\n        noCalls,\n        subscriptState,\n      );\n    }\n\n    parseNewCallee(node: N.NewExpression): void {\n      super.parseNewCallee(node);\n\n      let targs = null;\n      if (this.shouldParseTypes() && this.match(tt.lt)) {\n        targs = this.tryParse(() =>\n          this.flowParseTypeParameterInstantiationCallOrNew(),\n        ).node;\n      }\n      node.typeArguments = targs;\n    }\n\n    parseAsyncArrowWithTypeParameters(\n      startLoc: Position,\n    ): N.ArrowFunctionExpression | undefined | null {\n      const node = this.startNodeAt<N.ArrowFunctionExpression>(startLoc);\n      this.parseFunctionParams(node, false);\n      if (!this.parseArrow(node)) return;\n      return super.parseArrowExpression(\n        node,\n        /* params */ undefined,\n        /* isAsync */ true,\n      );\n    }\n\n    readToken_mult_modulo(code: number): void {\n      const next = this.input.charCodeAt(this.state.pos + 1);\n      if (\n        code === charCodes.asterisk &&\n        next === charCodes.slash &&\n        this.state.hasFlowComment\n      ) {\n        this.state.hasFlowComment = false;\n        this.state.pos += 2;\n        this.nextToken();\n        return;\n      }\n\n      super.readToken_mult_modulo(code);\n    }\n\n    readToken_pipe_amp(code: number): void {\n      const next = this.input.charCodeAt(this.state.pos + 1);\n      if (\n        code === charCodes.verticalBar &&\n        next === charCodes.rightCurlyBrace\n      ) {\n        // '|}'\n        this.finishOp(tt.braceBarR, 2);\n        return;\n      }\n\n      super.readToken_pipe_amp(code);\n    }\n\n    parseTopLevel(file: N.File, program: N.Program): N.File {\n      const fileNode = super.parseTopLevel(file, program);\n      if (this.state.hasFlowComment) {\n        this.raise(FlowErrors.UnterminatedFlowComment, {\n          at: this.state.curPosition(),\n        });\n      }\n      return fileNode;\n    }\n\n    skipBlockComment(): N.CommentBlock | undefined {\n      if (this.hasPlugin(\"flowComments\") && this.skipFlowComment()) {\n        if (this.state.hasFlowComment) {\n          throw this.raise(FlowErrors.NestedFlowComment, {\n            at: this.state.startLoc,\n          });\n        }\n        this.hasFlowCommentCompletion();\n        const commentSkip = this.skipFlowComment();\n        if (commentSkip) {\n          this.state.pos += commentSkip;\n          this.state.hasFlowComment = true;\n        }\n        return;\n      }\n\n      return super.skipBlockComment(this.state.hasFlowComment ? \"*-/\" : \"*/\");\n    }\n\n    skipFlowComment(): number | false {\n      const { pos } = this.state;\n      let shiftToFirstNonWhiteSpace = 2;\n      while (\n        [charCodes.space, charCodes.tab].includes(\n          // @ts-expect-error testing whether a number is included\n          this.input.charCodeAt(pos + shiftToFirstNonWhiteSpace),\n        )\n      ) {\n        shiftToFirstNonWhiteSpace++;\n      }\n\n      const ch2 = this.input.charCodeAt(shiftToFirstNonWhiteSpace + pos);\n      const ch3 = this.input.charCodeAt(shiftToFirstNonWhiteSpace + pos + 1);\n\n      if (ch2 === charCodes.colon && ch3 === charCodes.colon) {\n        return shiftToFirstNonWhiteSpace + 2; // check for /*::\n      }\n      if (\n        this.input.slice(\n          shiftToFirstNonWhiteSpace + pos,\n          shiftToFirstNonWhiteSpace + pos + 12,\n        ) === \"flow-include\"\n      ) {\n        return shiftToFirstNonWhiteSpace + 12; // check for /*flow-include\n      }\n      if (ch2 === charCodes.colon && ch3 !== charCodes.colon) {\n        return shiftToFirstNonWhiteSpace; // check for /*:, advance up to :\n      }\n      return false;\n    }\n\n    hasFlowCommentCompletion(): void {\n      const end = this.input.indexOf(\"*/\", this.state.pos);\n      if (end === -1) {\n        throw this.raise(Errors.UnterminatedComment, {\n          at: this.state.curPosition(),\n        });\n      }\n    }\n\n    // Flow enum parsing\n\n    flowEnumErrorBooleanMemberNotInitialized(\n      loc: Position,\n      {\n        enumName,\n        memberName,\n      }: {\n        enumName: string;\n        memberName: string;\n      },\n    ): void {\n      this.raise(FlowErrors.EnumBooleanMemberNotInitialized, {\n        at: loc,\n        memberName,\n        enumName,\n      });\n    }\n\n    flowEnumErrorInvalidMemberInitializer(\n      loc: Position,\n      enumContext: EnumContext,\n    ) {\n      return this.raise(\n        !enumContext.explicitType\n          ? FlowErrors.EnumInvalidMemberInitializerUnknownType\n          : enumContext.explicitType === \"symbol\"\n          ? FlowErrors.EnumInvalidMemberInitializerSymbolType\n          : FlowErrors.EnumInvalidMemberInitializerPrimaryType,\n        {\n          at: loc,\n          ...enumContext,\n        },\n      );\n    }\n\n    flowEnumErrorNumberMemberNotInitialized(\n      loc: Position,\n      {\n        enumName,\n        memberName,\n      }: {\n        enumName: string;\n        memberName: string;\n      },\n    ): void {\n      this.raise(FlowErrors.EnumNumberMemberNotInitialized, {\n        at: loc,\n        enumName,\n        memberName,\n      });\n    }\n\n    flowEnumErrorStringMemberInconsistentlyInitailized(\n      node: N.Node,\n      {\n        enumName,\n      }: {\n        enumName: string;\n      },\n    ): void {\n      this.raise(FlowErrors.EnumStringMemberInconsistentlyInitailized, {\n        at: node,\n        enumName,\n      });\n    }\n\n    flowEnumMemberInit(): EnumMemberInit {\n      const startLoc = this.state.startLoc;\n      const endOfInit = () => this.match(tt.comma) || this.match(tt.braceR);\n      switch (this.state.type) {\n        case tt.num: {\n          const literal = this.parseNumericLiteral(this.state.value);\n          if (endOfInit()) {\n            return { type: \"number\", loc: literal.loc.start, value: literal };\n          }\n          return { type: \"invalid\", loc: startLoc };\n        }\n        case tt.string: {\n          const literal = this.parseStringLiteral(this.state.value);\n          if (endOfInit()) {\n            return { type: \"string\", loc: literal.loc.start, value: literal };\n          }\n          return { type: \"invalid\", loc: startLoc };\n        }\n        case tt._true:\n        case tt._false: {\n          const literal = this.parseBooleanLiteral(this.match(tt._true));\n          if (endOfInit()) {\n            return {\n              type: \"boolean\",\n              loc: literal.loc.start,\n              value: literal,\n            };\n          }\n          return { type: \"invalid\", loc: startLoc };\n        }\n        default:\n          return { type: \"invalid\", loc: startLoc };\n      }\n    }\n\n    flowEnumMemberRaw(): {\n      id: N.Node;\n      init: EnumMemberInit;\n    } {\n      const loc = this.state.startLoc;\n      const id = this.parseIdentifier(true);\n      const init = this.eat(tt.eq)\n        ? this.flowEnumMemberInit()\n        : { type: \"none\" as const, loc };\n      return { id, init };\n    }\n\n    flowEnumCheckExplicitTypeMismatch(\n      loc: Position,\n      context: EnumContext,\n      expectedType: EnumExplicitType,\n    ): void {\n      const { explicitType } = context;\n      if (explicitType === null) {\n        return;\n      }\n      if (explicitType !== expectedType) {\n        this.flowEnumErrorInvalidMemberInitializer(loc, context);\n      }\n    }\n\n    flowEnumMembers({\n      enumName,\n      explicitType,\n    }: {\n      enumName: string;\n      explicitType: EnumExplicitType;\n    }): {\n      members: {\n        booleanMembers: Array<N.Node>;\n        numberMembers: Array<N.Node>;\n        stringMembers: Array<N.Node>;\n        defaultedMembers: Array<N.Node>;\n      };\n      hasUnknownMembers: boolean;\n    } {\n      const seenNames = new Set();\n      const members = {\n        // @ts-expect-error: migrate to Babel types\n        booleanMembers: [],\n        // @ts-expect-error: migrate to Babel types\n        numberMembers: [],\n        // @ts-expect-error: migrate to Babel types\n        stringMembers: [],\n        // @ts-expect-error: migrate to Babel types\n        defaultedMembers: [],\n      };\n      let hasUnknownMembers = false;\n      while (!this.match(tt.braceR)) {\n        if (this.eat(tt.ellipsis)) {\n          hasUnknownMembers = true;\n          break;\n        }\n        const memberNode = this.startNode();\n        const { id, init } = this.flowEnumMemberRaw();\n        const memberName = id.name;\n        if (memberName === \"\") {\n          continue;\n        }\n        if (/^[a-z]/.test(memberName)) {\n          this.raise(FlowErrors.EnumInvalidMemberName, {\n            at: id,\n            memberName,\n            suggestion: memberName[0].toUpperCase() + memberName.slice(1),\n            enumName,\n          });\n        }\n        if (seenNames.has(memberName)) {\n          this.raise(FlowErrors.EnumDuplicateMemberName, {\n            at: id,\n            memberName,\n            enumName,\n          });\n        }\n        seenNames.add(memberName);\n        const context = { enumName, explicitType, memberName };\n        memberNode.id = id;\n        switch (init.type) {\n          case \"boolean\": {\n            this.flowEnumCheckExplicitTypeMismatch(\n              init.loc,\n              context,\n              \"boolean\",\n            );\n            memberNode.init = init.value;\n            members.booleanMembers.push(\n              this.finishNode(memberNode, \"EnumBooleanMember\"),\n            );\n            break;\n          }\n          case \"number\": {\n            this.flowEnumCheckExplicitTypeMismatch(init.loc, context, \"number\");\n            memberNode.init = init.value;\n            members.numberMembers.push(\n              this.finishNode(memberNode, \"EnumNumberMember\"),\n            );\n            break;\n          }\n          case \"string\": {\n            this.flowEnumCheckExplicitTypeMismatch(init.loc, context, \"string\");\n            memberNode.init = init.value;\n            members.stringMembers.push(\n              this.finishNode(memberNode, \"EnumStringMember\"),\n            );\n            break;\n          }\n          case \"invalid\": {\n            throw this.flowEnumErrorInvalidMemberInitializer(init.loc, context);\n          }\n          case \"none\": {\n            switch (explicitType) {\n              case \"boolean\":\n                this.flowEnumErrorBooleanMemberNotInitialized(\n                  init.loc,\n                  context,\n                );\n                break;\n              case \"number\":\n                this.flowEnumErrorNumberMemberNotInitialized(init.loc, context);\n                break;\n              default:\n                members.defaultedMembers.push(\n                  this.finishNode(memberNode, \"EnumDefaultedMember\"),\n                );\n            }\n          }\n        }\n\n        if (!this.match(tt.braceR)) {\n          this.expect(tt.comma);\n        }\n      }\n      return { members, hasUnknownMembers };\n    }\n\n    flowEnumStringMembers(\n      initializedMembers: Array<N.Node>,\n      defaultedMembers: Array<N.Node>,\n      {\n        enumName,\n      }: {\n        enumName: string;\n      },\n    ): Array<N.Node> {\n      if (initializedMembers.length === 0) {\n        return defaultedMembers;\n      } else if (defaultedMembers.length === 0) {\n        return initializedMembers;\n      } else if (defaultedMembers.length > initializedMembers.length) {\n        for (const member of initializedMembers) {\n          this.flowEnumErrorStringMemberInconsistentlyInitailized(member, {\n            enumName,\n          });\n        }\n        return defaultedMembers;\n      } else {\n        for (const member of defaultedMembers) {\n          this.flowEnumErrorStringMemberInconsistentlyInitailized(member, {\n            enumName,\n          });\n        }\n        return initializedMembers;\n      }\n    }\n\n    flowEnumParseExplicitType({\n      enumName,\n    }: {\n      enumName: string;\n    }): EnumExplicitType {\n      if (!this.eatContextual(tt._of)) return null;\n\n      if (!tokenIsIdentifier(this.state.type)) {\n        throw this.raise(FlowErrors.EnumInvalidExplicitTypeUnknownSupplied, {\n          at: this.state.startLoc,\n          enumName,\n        });\n      }\n\n      const { value } = this.state;\n      this.next();\n\n      if (\n        value !== \"boolean\" &&\n        value !== \"number\" &&\n        value !== \"string\" &&\n        value !== \"symbol\"\n      ) {\n        this.raise(FlowErrors.EnumInvalidExplicitType, {\n          at: this.state.startLoc,\n          enumName,\n          invalidEnumType: value,\n        });\n      }\n\n      return value;\n    }\n\n    flowEnumBody(node: Undone<N.Node>, id: N.Node): N.Node {\n      const enumName = id.name;\n      const nameLoc = id.loc.start;\n      const explicitType = this.flowEnumParseExplicitType({ enumName });\n      this.expect(tt.braceL);\n      const { members, hasUnknownMembers } = this.flowEnumMembers({\n        enumName,\n        explicitType,\n      });\n      node.hasUnknownMembers = hasUnknownMembers;\n\n      switch (explicitType) {\n        case \"boolean\":\n          node.explicitType = true;\n          node.members = members.booleanMembers;\n          this.expect(tt.braceR);\n          return this.finishNode(node, \"EnumBooleanBody\");\n        case \"number\":\n          node.explicitType = true;\n          node.members = members.numberMembers;\n          this.expect(tt.braceR);\n          return this.finishNode(node, \"EnumNumberBody\");\n        case \"string\":\n          node.explicitType = true;\n          node.members = this.flowEnumStringMembers(\n            members.stringMembers,\n            members.defaultedMembers,\n            { enumName },\n          );\n          this.expect(tt.braceR);\n          return this.finishNode(node, \"EnumStringBody\");\n        case \"symbol\":\n          node.members = members.defaultedMembers;\n          this.expect(tt.braceR);\n          return this.finishNode(node, \"EnumSymbolBody\");\n        default: {\n          // `explicitType` is `null`\n          const empty = () => {\n            node.members = [];\n            this.expect(tt.braceR);\n            return this.finishNode(node, \"EnumStringBody\");\n          };\n          node.explicitType = false;\n\n          const boolsLen = members.booleanMembers.length;\n          const numsLen = members.numberMembers.length;\n          const strsLen = members.stringMembers.length;\n          const defaultedLen = members.defaultedMembers.length;\n\n          if (!boolsLen && !numsLen && !strsLen && !defaultedLen) {\n            return empty();\n          } else if (!boolsLen && !numsLen) {\n            node.members = this.flowEnumStringMembers(\n              members.stringMembers,\n              members.defaultedMembers,\n              { enumName },\n            );\n            this.expect(tt.braceR);\n            return this.finishNode(node, \"EnumStringBody\");\n          } else if (!numsLen && !strsLen && boolsLen >= defaultedLen) {\n            for (const member of members.defaultedMembers) {\n              this.flowEnumErrorBooleanMemberNotInitialized(member.loc.start, {\n                enumName,\n                memberName: member.id.name,\n              });\n            }\n            node.members = members.booleanMembers;\n            this.expect(tt.braceR);\n            return this.finishNode(node, \"EnumBooleanBody\");\n          } else if (!boolsLen && !strsLen && numsLen >= defaultedLen) {\n            for (const member of members.defaultedMembers) {\n              this.flowEnumErrorNumberMemberNotInitialized(member.loc.start, {\n                enumName,\n                memberName: member.id.name,\n              });\n            }\n            node.members = members.numberMembers;\n            this.expect(tt.braceR);\n            return this.finishNode(node, \"EnumNumberBody\");\n          } else {\n            this.raise(FlowErrors.EnumInconsistentMemberValues, {\n              at: nameLoc,\n              enumName,\n            });\n            return empty();\n          }\n        }\n      }\n    }\n\n    flowParseEnumDeclaration(node: Undone<N.Node>): N.Node {\n      const id = this.parseIdentifier();\n      node.id = id;\n      node.body = this.flowEnumBody(this.startNode(), id);\n      return this.finishNode(node, \"EnumDeclaration\");\n    }\n\n    // check if the next token is a tt.lt\n    isLookaheadToken_lt(): boolean {\n      const next = this.nextTokenStart();\n      if (this.input.charCodeAt(next) === charCodes.lessThan) {\n        const afterNext = this.input.charCodeAt(next + 1);\n        return (\n          afterNext !== charCodes.lessThan && afterNext !== charCodes.equalsTo\n        );\n      }\n      return false;\n    }\n\n    maybeUnwrapTypeCastExpression(node: N.Node) {\n      return node.type === \"TypeCastExpression\" ? node.expression : node;\n    }\n  };\n"],"mappings":"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"}��������������������������������������������lib/plugins/flow/scope.js���������������������������������������������������������������������������0000644�����������������00000002461�15120211212�0011377 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;
var _scope = require("../../util/scope");
var _scopeflags = require("../../util/scopeflags");
class FlowScope extends _scope.Scope {
  constructor(...args) {
    super(...args);
    this.declareFunctions = new Set();
  }
}
class FlowScopeHandler extends _scope.default {
  createScope(flags) {
    return new FlowScope(flags);
  }
  declareName(name, bindingType, loc) {
    const scope = this.currentScope();
    if (bindingType & _scopeflags.BIND_FLAGS_FLOW_DECLARE_FN) {
      this.checkRedeclarationInScope(scope, name, bindingType, loc);
      this.maybeExportDefined(scope, name);
      scope.declareFunctions.add(name);
      return;
    }
    super.declareName(name, bindingType, loc);
  }
  isRedeclaredInScope(scope, name, bindingType) {
    if (super.isRedeclaredInScope(scope, name, bindingType)) return true;
    if (bindingType & _scopeflags.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);
    }
  }
}
exports.default = FlowScopeHandler;

//# sourceMappingURL=scope.js.map
���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������lib/plugins/flow/scope.js.map�����������������������������������������������������������������������0000644�����������������00000006576�15120211212�0012166 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������{"version":3,"names":["_scope","require","_scopeflags","FlowScope","Scope","constructor","args","declareFunctions","Set","FlowScopeHandler","ScopeHandler","createScope","flags","declareName","name","bindingType","loc","scope","currentScope","BIND_FLAGS_FLOW_DECLARE_FN","checkRedeclarationInScope","maybeExportDefined","add","isRedeclaredInScope","has","lexical","functions","checkLocalExport","id","scopeStack","exports","default"],"sources":["../../../src/plugins/flow/scope.ts"],"sourcesContent":["import type { 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 type * 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<string> = new Set();\n}\n\nexport default class FlowScopeHandler extends ScopeHandler<FlowScope> {\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(name, bindingType, loc);\n  }\n\n  isRedeclaredInScope(\n    scope: FlowScope,\n    name: string,\n    bindingType: BindingTypes,\n  ): boolean {\n    if (super.isRedeclaredInScope(scope, name, bindingType)) 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"],"mappings":";;;;;;AACA,IAAAA,MAAA,GAAAC,OAAA;AACA,IAAAC,WAAA,GAAAD,OAAA;AAQA,MAAME,SAAS,SAASC,YAAK,CAAC;EAAAC,YAAA,GAAAC,IAAA;IAAA,SAAAA,IAAA;IAAA,KAE5BC,gBAAgB,GAAgB,IAAIC,GAAG,CAAC,CAAC;EAAA;AAC3C;AAEe,MAAMC,gBAAgB,SAASC,cAAY,CAAY;EACpEC,WAAWA,CAACC,KAAiB,EAAa;IACxC,OAAO,IAAIT,SAAS,CAACS,KAAK,CAAC;EAC7B;EAEAC,WAAWA,CAACC,IAAY,EAAEC,WAAyB,EAAEC,GAAa,EAAE;IAClE,MAAMC,KAAK,GAAG,IAAI,CAACC,YAAY,CAAC,CAAC;IACjC,IAAIH,WAAW,GAAGI,sCAA0B,EAAE;MAC5C,IAAI,CAACC,yBAAyB,CAACH,KAAK,EAAEH,IAAI,EAAEC,WAAW,EAAEC,GAAG,CAAC;MAC7D,IAAI,CAACK,kBAAkB,CAACJ,KAAK,EAAEH,IAAI,CAAC;MACpCG,KAAK,CAACV,gBAAgB,CAACe,GAAG,CAACR,IAAI,CAAC;MAChC;IACF;IAEA,KAAK,CAACD,WAAW,CAACC,IAAI,EAAEC,WAAW,EAAEC,GAAG,CAAC;EAC3C;EAEAO,mBAAmBA,CACjBN,KAAgB,EAChBH,IAAY,EACZC,WAAyB,EAChB;IACT,IAAI,KAAK,CAACQ,mBAAmB,CAACN,KAAK,EAAEH,IAAI,EAAEC,WAAW,CAAC,EAAE,OAAO,IAAI;IAEpE,IAAIA,WAAW,GAAGI,sCAA0B,EAAE;MAC5C,OACE,CAACF,KAAK,CAACV,gBAAgB,CAACiB,GAAG,CAACV,IAAI,CAAC,KAChCG,KAAK,CAACQ,OAAO,CAACD,GAAG,CAACV,IAAI,CAAC,IAAIG,KAAK,CAACS,SAAS,CAACF,GAAG,CAACV,IAAI,CAAC,CAAC;IAE1D;IAEA,OAAO,KAAK;EACd;EAEAa,gBAAgBA,CAACC,EAAgB,EAAE;IACjC,IAAI,CAAC,IAAI,CAACC,UAAU,CAAC,CAAC,CAAC,CAACtB,gBAAgB,CAACiB,GAAG,CAACI,EAAE,CAACd,IAAI,CAAC,EAAE;MACrD,KAAK,CAACa,gBAAgB,CAACC,EAAE,CAAC;IAC5B;EACF;AACF;AAACE,OAAA,CAAAC,OAAA,GAAAtB,gBAAA"}����������������������������������������������������������������������������������������������������������������������������������lib/plugins/jsx/index.js����������������������������������������������������������������������������0000644�����������������00000034763�15120211212�0011244 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;
var _xhtml = require("./xhtml");
var _types = require("../../tokenizer/types");
var _context = require("../../tokenizer/context");
var _identifier = require("../../util/identifier");
var _whitespace = require("../../util/whitespace");
var _parseError = require("../../parse-error");
const JsxErrors = (0, _parseError.ParseErrorEnum)`jsx`({
  AttributeIsEmpty: "JSX attributes must only be assigned a non-empty expression.",
  MissingClosingTagElement: ({
    openingTagName
  }) => `Expected corresponding JSX closing tag for <${openingTagName}>.`,
  MissingClosingTagFragment: "Expected corresponding JSX closing tag for <>.",
  UnexpectedSequenceExpression: "Sequence expressions cannot be directly nested inside JSX. Did you mean to wrap it in parentheses (...)?",
  UnexpectedToken: ({
    unexpected,
    HTMLEntity
  }) => `Unexpected token \`${unexpected}\`. Did you mean \`${HTMLEntity}\` or \`{'${unexpected}'}\`?`,
  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 <>...</>?"
});
function isFragment(object) {
  return object ? object.type === "JSXOpeningFragment" || object.type === "JSXClosingFragment" : false;
}
function getQualifiedJSXName(object) {
  if (object.type === "JSXIdentifier") {
    return object.name;
  }
  if (object.type === "JSXNamespacedName") {
    return object.namespace.name + ":" + object.name.name;
  }
  if (object.type === "JSXMemberExpression") {
    return getQualifiedJSXName(object.object) + "." + getQualifiedJSXName(object.property);
  }
  throw new Error("Node had unexpected type: " + object.type);
}
var _default = superClass => class JSXParserMixin 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;
              this.finishToken(140);
            } else {
              super.getTokenFromCode(ch);
            }
            return;
          }
          out += this.input.slice(chunkStart, this.state.pos);
          this.finishToken(139, out);
          return;
        case 38:
          out += this.input.slice(chunkStart, this.state.pos);
          out += this.jsxReadEntity();
          chunkStart = this.state.pos;
          break;
        case 62:
        case 125:
          ;
        default:
          if ((0, _whitespace.isNewLine)(ch)) {
            out += this.input.slice(chunkStart, this.state.pos);
            out += this.jsxReadNewLine(true);
            chunkStart = this.state.pos;
          } else {
            ++this.state.pos;
          }
      }
    }
  }
  jsxReadNewLine(normalizeCRLF) {
    const ch = this.input.charCodeAt(this.state.pos);
    let out;
    ++this.state.pos;
    if (ch === 13 && this.input.charCodeAt(this.state.pos) === 10) {
      ++this.state.pos;
      out = normalizeCRLF ? "\n" : "\r\n";
    } else {
      out = String.fromCharCode(ch);
    }
    ++this.state.curLine;
    this.state.lineStart = this.state.pos;
    return out;
  }
  jsxReadString(quote) {
    let out = "";
    let chunkStart = ++this.state.pos;
    for (;;) {
      if (this.state.pos >= this.length) {
        throw this.raise(_parseError.Errors.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 ((0, _whitespace.isNewLine)(ch)) {
        out += this.input.slice(chunkStart, this.state.pos);
        out += this.jsxReadNewLine(false);
        chunkStart = this.state.pos;
      } else {
        ++this.state.pos;
      }
    }
    out += this.input.slice(chunkStart, this.state.pos++);
    this.finishToken(131, out);
  }
  jsxReadEntity() {
    const startPos = ++this.state.pos;
    if (this.codePointAtPos(this.state.pos) === 35) {
      ++this.state.pos;
      let radix = 10;
      if (this.codePointAtPos(this.state.pos) === 120) {
        radix = 16;
        ++this.state.pos;
      }
      const codePoint = this.readInt(radix, undefined, false, "bail");
      if (codePoint !== null && this.codePointAtPos(this.state.pos) === 59) {
        ++this.state.pos;
        return String.fromCodePoint(codePoint);
      }
    } else {
      let count = 0;
      let semi = false;
      while (count++ < 10 && this.state.pos < this.length && !(semi = this.codePointAtPos(this.state.pos) == 59)) {
        ++this.state.pos;
      }
      if (semi) {
        const desc = this.input.slice(startPos, this.state.pos);
        const entity = _xhtml.default[desc];
        ++this.state.pos;
        if (entity) {
          return entity;
        }
      }
    }
    this.state.pos = startPos;
    return "&";
  }
  jsxReadWord() {
    let ch;
    const start = this.state.pos;
    do {
      ch = this.input.charCodeAt(++this.state.pos);
    } while ((0, _identifier.isIdentifierChar)(ch) || ch === 45);
    this.finishToken(138, this.input.slice(start, this.state.pos));
  }
  jsxParseIdentifier() {
    const node = this.startNode();
    if (this.match(138)) {
      node.name = this.state.value;
    } else if ((0, _types.tokenIsKeyword)(this.state.type)) {
      node.name = (0, _types.tokenLabelName)(this.state.type);
    } else {
      this.unexpected();
    }
    this.next();
    return this.finishNode(node, "JSXIdentifier");
  }
  jsxParseNamespacedName() {
    const startLoc = this.state.startLoc;
    const name = this.jsxParseIdentifier();
    if (!this.eat(14)) return name;
    const node = this.startNodeAt(startLoc);
    node.namespace = name;
    node.name = this.jsxParseIdentifier();
    return this.finishNode(node, "JSXNamespacedName");
  }
  jsxParseElementName() {
    const startLoc = this.state.startLoc;
    let node = this.jsxParseNamespacedName();
    if (node.type === "JSXNamespacedName") {
      return node;
    }
    while (this.eat(16)) {
      const newNode = this.startNodeAt(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(_context.types.brace);
        this.next();
        node = this.jsxParseExpressionContainer(node, _context.types.j_oTag);
        if (node.expression.type === "JSXEmptyExpression") {
          this.raise(JsxErrors.AttributeIsEmpty, {
            at: node
          });
        }
        return node;
      case 140:
      case 131:
        return this.parseExprAtom();
      default:
        throw this.raise(JsxErrors.UnsupportedJsxValue, {
          at: this.state.startLoc
        });
    }
  }
  jsxParseEmptyExpression() {
    const node = this.startNodeAt(this.state.lastTokEndLoc);
    return this.finishNodeAt(node, "JSXEmptyExpression", this.state.startLoc);
  }
  jsxParseSpreadChild(node) {
    this.next();
    node.expression = this.parseExpression();
    this.setContext(_context.types.j_expr);
    this.state.canStartJSXElement = true;
    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.state.canStartJSXElement = true;
    this.expect(8);
    return this.finishNode(node, "JSXExpressionContainer");
  }
  jsxParseAttribute() {
    const node = this.startNode();
    if (this.match(5)) {
      this.setContext(_context.types.brace);
      this.next();
      this.expect(21);
      node.argument = this.parseMaybeAssignAllowIn();
      this.setContext(_context.types.j_oTag);
      this.state.canStartJSXElement = true;
      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(startLoc) {
    const node = this.startNodeAt(startLoc);
    if (this.eat(141)) {
      return this.finishNode(node, "JSXOpeningFragment");
    }
    node.name = this.jsxParseElementName();
    return this.jsxParseOpeningElementAfterName(node);
  }
  jsxParseOpeningElementAfterName(node) {
    const attributes = [];
    while (!this.match(56) && !this.match(141)) {
      attributes.push(this.jsxParseAttribute());
    }
    node.attributes = attributes;
    node.selfClosing = this.eat(56);
    this.expect(141);
    return this.finishNode(node, "JSXOpeningElement");
  }
  jsxParseClosingElementAt(startLoc) {
    const node = this.startNodeAt(startLoc);
    if (this.eat(141)) {
      return this.finishNode(node, "JSXClosingFragment");
    }
    node.name = this.jsxParseElementName();
    this.expect(141);
    return this.finishNode(node, "JSXClosingElement");
  }
  jsxParseElementAt(startLoc) {
    const node = this.startNodeAt(startLoc);
    const children = [];
    const openingElement = this.jsxParseOpeningElementAt(startLoc);
    let closingElement = null;
    if (!openingElement.selfClosing) {
      contents: for (;;) {
        switch (this.state.type) {
          case 140:
            startLoc = this.state.startLoc;
            this.next();
            if (this.eat(56)) {
              closingElement = this.jsxParseClosingElementAt(startLoc);
              break contents;
            }
            children.push(this.jsxParseElementAt(startLoc));
            break;
          case 139:
            children.push(this.parseExprAtom());
            break;
          case 5:
            {
              const node = this.startNode();
              this.setContext(_context.types.brace);
              this.next();
              if (this.match(21)) {
                children.push(this.jsxParseSpreadChild(node));
              } else {
                children.push(this.jsxParseExpressionContainer(node, _context.types.j_expr));
              }
              break;
            }
          default:
            this.unexpected();
        }
      }
      if (isFragment(openingElement) && !isFragment(closingElement) && closingElement !== null) {
        this.raise(JsxErrors.MissingClosingTagFragment, {
          at: closingElement
        });
      } else if (!isFragment(openingElement) && isFragment(closingElement)) {
        this.raise(JsxErrors.MissingClosingTagElement, {
          at: closingElement,
          openingTagName: getQualifiedJSXName(openingElement.name)
        });
      } else if (!isFragment(openingElement) && !isFragment(closingElement)) {
        if (getQualifiedJSXName(closingElement.name) !== getQualifiedJSXName(openingElement.name)) {
          this.raise(JsxErrors.MissingClosingTagElement, {
            at: closingElement,
            openingTagName: 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 startLoc = this.state.startLoc;
    this.next();
    return this.jsxParseElementAt(startLoc);
  }
  setContext(newContext) {
    const {
      context
    } = this.state;
    context[context.length - 1] = newContext;
  }
  parseExprAtom(refExpressionErrors) {
    if (this.match(139)) {
      return this.parseLiteral(this.state.value, "JSXText");
    } else if (this.match(140)) {
      return this.jsxParseElement();
    } else if (this.match(47) && this.input.charCodeAt(this.state.pos) !== 33) {
      this.replaceToken(140);
      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 === _context.types.j_expr) {
      this.jsxReadToken();
      return;
    }
    if (context === _context.types.j_oTag || context === _context.types.j_cTag) {
      if ((0, _identifier.isIdentifierStart)(code)) {
        this.jsxReadWord();
        return;
      }
      if (code === 62) {
        ++this.state.pos;
        this.finishToken(141);
        return;
      }
      if ((code === 34 || code === 39) && context === _context.types.j_oTag) {
        this.jsxReadString(code);
        return;
      }
    }
    if (code === 60 && this.state.canStartJSXElement && this.input.charCodeAt(this.state.pos + 1) !== 33) {
      ++this.state.pos;
      this.finishToken(140);
      return;
    }
    super.getTokenFromCode(code);
  }
  updateContext(prevType) {
    const {
      context,
      type
    } = this.state;
    if (type === 56 && prevType === 140) {
      context.splice(-2, 2, _context.types.j_cTag);
      this.state.canStartJSXElement = false;
    } else if (type === 140) {
      context.push(_context.types.j_oTag);
    } else if (type === 141) {
      const out = context[context.length - 1];
      if (out === _context.types.j_oTag && prevType === 56 || out === _context.types.j_cTag) {
        context.pop();
        this.state.canStartJSXElement = context[context.length - 1] === _context.types.j_expr;
      } else {
        this.setContext(_context.types.j_expr);
        this.state.canStartJSXElement = true;
      }
    } else {
      this.state.canStartJSXElement = (0, _types.tokenComesBeforeExpression)(type);
    }
  }
};
exports.default = _default;

//# sourceMappingURL=index.js.map
�������������lib/plugins/jsx/index.js.map������������������������������������������������������������������������0000644�����������������00000114066�15120211212�0012013 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������{"version":3,"names":["_xhtml","require","_types","_context","_identifier","_whitespace","_parseError","JsxErrors","ParseErrorEnum","AttributeIsEmpty","MissingClosingTagElement","openingTagName","MissingClosingTagFragment","UnexpectedSequenceExpression","UnexpectedToken","unexpected","HTMLEntity","UnsupportedJsxValue","UnterminatedJsxContent","UnwrappedAdjacentJSXElements","isFragment","object","type","getQualifiedJSXName","name","namespace","property","Error","_default","superClass","JSXParserMixin","jsxReadToken","out","chunkStart","state","pos","length","raise","at","startLoc","ch","input","charCodeAt","start","canStartJSXElement","finishToken","getTokenFromCode","slice","jsxReadEntity","isNewLine","jsxReadNewLine","normalizeCRLF","String","fromCharCode","curLine","lineStart","jsxReadString","quote","Errors","UnterminatedString","startPos","codePointAtPos","radix","codePoint","readInt","undefined","fromCodePoint","count","semi","desc","entity","XHTMLEntities","jsxReadWord","isIdentifierChar","jsxParseIdentifier","node","startNode","match","value","tokenIsKeyword","tokenLabelName","next","finishNode","jsxParseNamespacedName","eat","startNodeAt","jsxParseElementName","newNode","jsxParseAttributeValue","setContext","tc","brace","jsxParseExpressionContainer","j_oTag","expression","parseExprAtom","jsxParseEmptyExpression","lastTokEndLoc","finishNodeAt","jsxParseSpreadChild","parseExpression","j_expr","expect","previousContext","jsxParseAttribute","argument","parseMaybeAssignAllowIn","jsxParseOpeningElementAt","jsxParseOpeningElementAfterName","attributes","push","selfClosing","jsxParseClosingElementAt","jsxParseElementAt","children","openingElement","closingElement","contents","openingFragment","closingFragment","jsxParseElement","newContext","context","refExpressionErrors","parseLiteral","replaceToken","skipSpace","curContext","preserveSpace","code","j_cTag","isIdentifierStart","updateContext","prevType","splice","pop","tokenComesBeforeExpression","exports","default"],"sources":["../../../src/plugins/jsx/index.ts"],"sourcesContent":["import * as charCodes from \"charcodes\";\n\nimport XHTMLEntities from \"./xhtml\";\nimport type Parser from \"../../parser\";\nimport type { ExpressionErrors } from \"../../parser/util\";\nimport {\n  tokenComesBeforeExpression,\n  tokenIsKeyword,\n  tokenLabelName,\n  type TokenType,\n  tt,\n} from \"../../tokenizer/types\";\nimport type { TokContext } from \"../../tokenizer/context\";\nimport { types as tc } from \"../../tokenizer/context\";\nimport type * as N from \"../../types\";\nimport { isIdentifierChar, isIdentifierStart } from \"../../util/identifier\";\nimport type { Position } from \"../../util/location\";\nimport { isNewLine } from \"../../util/whitespace\";\nimport { Errors, ParseErrorEnum } from \"../../parse-error\";\nimport type { Undone } from \"../../parser/node\";\n\n/* eslint sort-keys: \"error\" */\nconst JsxErrors = ParseErrorEnum`jsx`({\n  AttributeIsEmpty:\n    \"JSX attributes must only be assigned a non-empty expression.\",\n  MissingClosingTagElement: ({ openingTagName }: { openingTagName: string }) =>\n    `Expected corresponding JSX closing tag for <${openingTagName}>.`,\n  MissingClosingTagFragment: \"Expected corresponding JSX closing tag for <>.\",\n  UnexpectedSequenceExpression:\n    \"Sequence expressions cannot be directly nested inside JSX. Did you mean to wrap it in parentheses (...)?\",\n  // FIXME: Unify with Errors.UnexpectedToken\n  UnexpectedToken: ({\n    unexpected,\n    HTMLEntity,\n  }: {\n    unexpected: string;\n    HTMLEntity: string;\n  }) =>\n    `Unexpected token \\`${unexpected}\\`. Did you mean \\`${HTMLEntity}\\` or \\`{'${unexpected}'}\\`?`,\n  UnsupportedJsxValue:\n    \"JSX value should be either an expression or a quoted JSX text.\",\n  UnterminatedJsxContent: \"Unterminated JSX contents.\",\n  UnwrappedAdjacentJSXElements:\n    \"Adjacent JSX elements must be wrapped in an enclosing tag. Did you want a JSX fragment <>...</>?\",\n});\n\n/* eslint-disable sort-keys */\n\nfunction isFragment(object?: N.JSXElement | null): boolean {\n  return object\n    ? object.type === \"JSXOpeningFragment\" ||\n        object.type === \"JSXClosingFragment\"\n    : false;\n}\n\n// Transforms JSX element name to string.\n\nfunction getQualifiedJSXName(\n  object: N.JSXIdentifier | N.JSXNamespacedName | N.JSXMemberExpression,\n): string {\n  if (object.type === \"JSXIdentifier\") {\n    return object.name;\n  }\n\n  if (object.type === \"JSXNamespacedName\") {\n    return object.namespace.name + \":\" + object.name.name;\n  }\n\n  if (object.type === \"JSXMemberExpression\") {\n    return (\n      getQualifiedJSXName(object.object) +\n      \".\" +\n      getQualifiedJSXName(object.property)\n    );\n  }\n\n  // istanbul ignore next\n  throw new Error(\"Node had unexpected type: \" + object.type);\n}\n\nexport interface IJSXParserMixin {\n  jsxParseOpeningElementAfterName(\n    node: N.JSXOpeningElement,\n  ): N.JSXOpeningElement;\n}\n\nexport default (superClass: typeof Parser) =>\n  class JSXParserMixin extends superClass implements Parser, IJSXParserMixin {\n    // Reads inline JSX contents token.\n\n    jsxReadToken(): void {\n      let out = \"\";\n      let chunkStart = this.state.pos;\n      for (;;) {\n        if (this.state.pos >= this.length) {\n          throw this.raise(JsxErrors.UnterminatedJsxContent, {\n            at: this.state.startLoc,\n          });\n        }\n\n        const ch = this.input.charCodeAt(this.state.pos);\n\n        switch (ch) {\n          case charCodes.lessThan:\n          case charCodes.leftCurlyBrace:\n            if (this.state.pos === this.state.start) {\n              if (ch === charCodes.lessThan && this.state.canStartJSXElement) {\n                ++this.state.pos;\n                this.finishToken(tt.jsxTagStart);\n              } else {\n                super.getTokenFromCode(ch);\n              }\n              return;\n            }\n            out += this.input.slice(chunkStart, this.state.pos);\n            this.finishToken(tt.jsxText, out);\n            return;\n\n          case charCodes.ampersand:\n            out += this.input.slice(chunkStart, this.state.pos);\n            out += this.jsxReadEntity();\n            chunkStart = this.state.pos;\n            break;\n\n          case charCodes.greaterThan:\n          case charCodes.rightCurlyBrace:\n            if (process.env.BABEL_8_BREAKING) {\n              this.raise(JsxErrors.UnexpectedToken, {\n                at: this.state.curPosition(),\n                unexpected: this.input[this.state.pos],\n                HTMLEntity:\n                  ch === charCodes.rightCurlyBrace ? \"&rbrace;\" : \"&gt;\",\n              });\n            }\n          /* falls through */\n\n          default:\n            if (isNewLine(ch)) {\n              out += this.input.slice(chunkStart, this.state.pos);\n              out += this.jsxReadNewLine(true);\n              chunkStart = this.state.pos;\n            } else {\n              ++this.state.pos;\n            }\n        }\n      }\n    }\n\n    jsxReadNewLine(normalizeCRLF: boolean): string {\n      const ch = this.input.charCodeAt(this.state.pos);\n      let out;\n      ++this.state.pos;\n      if (\n        ch === charCodes.carriageReturn &&\n        this.input.charCodeAt(this.state.pos) === charCodes.lineFeed\n      ) {\n        ++this.state.pos;\n        out = normalizeCRLF ? \"\\n\" : \"\\r\\n\";\n      } else {\n        out = String.fromCharCode(ch);\n      }\n      ++this.state.curLine;\n      this.state.lineStart = this.state.pos;\n\n      return out;\n    }\n\n    jsxReadString(quote: number): void {\n      let out = \"\";\n      let chunkStart = ++this.state.pos;\n      for (;;) {\n        if (this.state.pos >= this.length) {\n          throw this.raise(Errors.UnterminatedString, {\n            at: this.state.startLoc,\n          });\n        }\n\n        const ch = this.input.charCodeAt(this.state.pos);\n        if (ch === quote) break;\n        if (ch === charCodes.ampersand) {\n          out += this.input.slice(chunkStart, this.state.pos);\n          out += this.jsxReadEntity();\n          chunkStart = this.state.pos;\n        } else if (isNewLine(ch)) {\n          out += this.input.slice(chunkStart, this.state.pos);\n          out += this.jsxReadNewLine(false);\n          chunkStart = this.state.pos;\n        } else {\n          ++this.state.pos;\n        }\n      }\n      out += this.input.slice(chunkStart, this.state.pos++);\n      this.finishToken(tt.string, out);\n    }\n\n    jsxReadEntity(): string {\n      const startPos = ++this.state.pos;\n      if (this.codePointAtPos(this.state.pos) === charCodes.numberSign) {\n        ++this.state.pos;\n\n        let radix = 10;\n        if (this.codePointAtPos(this.state.pos) === charCodes.lowercaseX) {\n          radix = 16;\n          ++this.state.pos;\n        }\n\n        const codePoint = this.readInt(\n          radix,\n          /* len */ undefined,\n          /* forceLen */ false,\n          /* allowNumSeparator */ \"bail\",\n        );\n        if (\n          codePoint !== null &&\n          this.codePointAtPos(this.state.pos) === charCodes.semicolon\n        ) {\n          ++this.state.pos;\n          return String.fromCodePoint(codePoint);\n        }\n      } else {\n        let count = 0;\n        let semi = false;\n        while (\n          count++ < 10 &&\n          this.state.pos < this.length &&\n          !(semi = this.codePointAtPos(this.state.pos) == charCodes.semicolon)\n        ) {\n          ++this.state.pos;\n        }\n\n        if (semi) {\n          const desc = this.input.slice(startPos, this.state.pos);\n          const entity = XHTMLEntities[desc];\n          ++this.state.pos;\n\n          if (entity) {\n            return entity;\n          }\n        }\n      }\n\n      // Not a valid entity\n      this.state.pos = startPos;\n      return \"&\";\n    }\n\n    // Read a JSX identifier (valid tag or attribute name).\n    //\n    // Optimized version since JSX identifiers can\"t contain\n    // escape characters and so can be read as single slice.\n    // Also assumes that first character was already checked\n    // by isIdentifierStart in readToken.\n\n    jsxReadWord(): void {\n      let ch;\n      const start = this.state.pos;\n      do {\n        ch = this.input.charCodeAt(++this.state.pos);\n      } while (isIdentifierChar(ch) || ch === charCodes.dash);\n      this.finishToken(tt.jsxName, this.input.slice(start, this.state.pos));\n    }\n\n    // Parse next token as JSX identifier\n\n    jsxParseIdentifier(): N.JSXIdentifier {\n      const node = this.startNode();\n      if (this.match(tt.jsxName)) {\n        node.name = this.state.value;\n      } else if (tokenIsKeyword(this.state.type)) {\n        node.name = tokenLabelName(this.state.type);\n      } else {\n        this.unexpected();\n      }\n      this.next();\n      return this.finishNode(node, \"JSXIdentifier\");\n    }\n\n    // Parse namespaced identifier.\n\n    jsxParseNamespacedName(): N.JSXNamespacedName {\n      const startLoc = this.state.startLoc;\n      const name = this.jsxParseIdentifier();\n      if (!this.eat(tt.colon)) return name;\n\n      const node = this.startNodeAt(startLoc);\n      node.namespace = name;\n      node.name = this.jsxParseIdentifier();\n      return this.finishNode(node, \"JSXNamespacedName\");\n    }\n\n    // Parses element name in any form - namespaced, member\n    // or single identifier.\n\n    jsxParseElementName():\n      | N.JSXIdentifier\n      | N.JSXNamespacedName\n      | N.JSXMemberExpression {\n      const startLoc = this.state.startLoc;\n      let node = this.jsxParseNamespacedName();\n      if (node.type === \"JSXNamespacedName\") {\n        return node;\n      }\n      while (this.eat(tt.dot)) {\n        const newNode = this.startNodeAt(startLoc);\n        newNode.object = node;\n        newNode.property = this.jsxParseIdentifier();\n        node = this.finishNode(newNode, \"JSXMemberExpression\");\n      }\n      return node;\n    }\n\n    // Parses any type of JSX attribute value.\n\n    jsxParseAttributeValue(): N.Expression {\n      let node;\n      switch (this.state.type) {\n        case tt.braceL:\n          node = this.startNode();\n          this.setContext(tc.brace);\n          this.next();\n          node = this.jsxParseExpressionContainer(node, tc.j_oTag);\n          if (node.expression.type === \"JSXEmptyExpression\") {\n            this.raise(JsxErrors.AttributeIsEmpty, { at: node });\n          }\n          return node;\n\n        case tt.jsxTagStart:\n        case tt.string:\n          return this.parseExprAtom();\n\n        default:\n          throw this.raise(JsxErrors.UnsupportedJsxValue, {\n            at: this.state.startLoc,\n          });\n      }\n    }\n\n    // JSXEmptyExpression is unique type since it doesn't actually parse anything,\n    // and so it should start at the end of last read token (left brace) and finish\n    // at the beginning of the next one (right brace).\n\n    jsxParseEmptyExpression(): N.JSXEmptyExpression {\n      const node = this.startNodeAt(this.state.lastTokEndLoc);\n      return this.finishNodeAt(node, \"JSXEmptyExpression\", this.state.startLoc);\n    }\n\n    // Parse JSX spread child\n\n    jsxParseSpreadChild(node: Undone<N.JSXSpreadChild>): N.JSXSpreadChild {\n      this.next(); // ellipsis\n      node.expression = this.parseExpression();\n      this.setContext(tc.j_expr);\n      this.state.canStartJSXElement = true;\n      this.expect(tt.braceR);\n\n      return this.finishNode(node, \"JSXSpreadChild\");\n    }\n\n    // Parses JSX expression enclosed into curly brackets.\n\n    jsxParseExpressionContainer(\n      node: Undone<N.JSXExpressionContainer>,\n      previousContext: TokContext,\n    ): N.JSXExpressionContainer {\n      if (this.match(tt.braceR)) {\n        node.expression = this.jsxParseEmptyExpression();\n      } else {\n        const expression = this.parseExpression();\n\n        if (process.env.BABEL_8_BREAKING) {\n          if (\n            expression.type === \"SequenceExpression\" &&\n            !expression.extra?.parenthesized\n          ) {\n            this.raise(JsxErrors.UnexpectedSequenceExpression, {\n              at: expression.expressions[1],\n            });\n          }\n        }\n\n        node.expression = expression;\n      }\n      this.setContext(previousContext);\n      this.state.canStartJSXElement = true;\n      this.expect(tt.braceR);\n\n      return this.finishNode(node, \"JSXExpressionContainer\");\n    }\n\n    // Parses following JSX attribute name-value pair.\n\n    jsxParseAttribute(): N.JSXAttribute {\n      const node = this.startNode();\n      if (this.match(tt.braceL)) {\n        this.setContext(tc.brace);\n        this.next();\n        this.expect(tt.ellipsis);\n        node.argument = this.parseMaybeAssignAllowIn();\n        this.setContext(tc.j_oTag);\n        this.state.canStartJSXElement = true;\n        this.expect(tt.braceR);\n        return this.finishNode(node, \"JSXSpreadAttribute\");\n      }\n      node.name = this.jsxParseNamespacedName();\n      node.value = this.eat(tt.eq) ? this.jsxParseAttributeValue() : null;\n      return this.finishNode(node, \"JSXAttribute\");\n    }\n\n    // Parses JSX opening tag starting after \"<\".\n\n    jsxParseOpeningElementAt(startLoc: Position): N.JSXOpeningElement {\n      const node = this.startNodeAt<N.JSXOpeningElement | N.JSXOpeningFragment>(\n        startLoc,\n      );\n      if (this.eat(tt.jsxTagEnd)) {\n        // @ts-expect-error migrate to Babel types\n        return this.finishNode(node, \"JSXOpeningFragment\");\n      }\n      node.name = this.jsxParseElementName();\n      return this.jsxParseOpeningElementAfterName(\n        node as Undone<N.JSXOpeningElement>,\n      );\n    }\n\n    jsxParseOpeningElementAfterName(\n      node: Undone<N.JSXOpeningElement>,\n    ): N.JSXOpeningElement {\n      const attributes: N.JSXAttribute[] = [];\n      while (!this.match(tt.slash) && !this.match(tt.jsxTagEnd)) {\n        attributes.push(this.jsxParseAttribute());\n      }\n      node.attributes = attributes;\n      node.selfClosing = this.eat(tt.slash);\n      this.expect(tt.jsxTagEnd);\n      return this.finishNode(node, \"JSXOpeningElement\");\n    }\n\n    // Parses JSX closing tag starting after \"</\".\n\n    jsxParseClosingElementAt(startLoc: Position): N.JSXClosingElement {\n      const node = this.startNodeAt(startLoc);\n      if (this.eat(tt.jsxTagEnd)) {\n        return this.finishNode(node, \"JSXClosingFragment\");\n      }\n      node.name = this.jsxParseElementName();\n      this.expect(tt.jsxTagEnd);\n      return this.finishNode(node, \"JSXClosingElement\");\n    }\n\n    // Parses entire JSX element, including it\"s opening tag\n    // (starting after \"<\"), attributes, contents and closing tag.\n\n    jsxParseElementAt(startLoc: Position): N.JSXElement {\n      const node = this.startNodeAt(startLoc);\n      const children = [];\n      const openingElement = this.jsxParseOpeningElementAt(startLoc);\n      let closingElement = null;\n\n      if (!openingElement.selfClosing) {\n        contents: for (;;) {\n          switch (this.state.type) {\n            case tt.jsxTagStart:\n              startLoc = this.state.startLoc;\n              this.next();\n              if (this.eat(tt.slash)) {\n                closingElement = this.jsxParseClosingElementAt(startLoc);\n                break contents;\n              }\n              children.push(this.jsxParseElementAt(startLoc));\n              break;\n\n            case tt.jsxText:\n              children.push(this.parseExprAtom());\n              break;\n\n            case tt.braceL: {\n              const node = this.startNode<\n                N.JSXSpreadChild | N.JSXExpressionContainer\n              >();\n              this.setContext(tc.brace);\n              this.next();\n              if (this.match(tt.ellipsis)) {\n                children.push(this.jsxParseSpreadChild(node));\n              } else {\n                children.push(\n                  this.jsxParseExpressionContainer(node, tc.j_expr),\n                );\n              }\n\n              break;\n            }\n            // istanbul ignore next - should never happen\n            default:\n              this.unexpected();\n          }\n        }\n\n        if (\n          isFragment(openingElement) &&\n          !isFragment(closingElement) &&\n          closingElement !== null\n        ) {\n          this.raise(JsxErrors.MissingClosingTagFragment, {\n            at: closingElement,\n          });\n        } else if (!isFragment(openingElement) && isFragment(closingElement)) {\n          this.raise(JsxErrors.MissingClosingTagElement, {\n            at: closingElement,\n            openingTagName: getQualifiedJSXName(openingElement.name),\n          });\n        } else if (!isFragment(openingElement) && !isFragment(closingElement)) {\n          if (\n            getQualifiedJSXName(closingElement.name) !==\n            getQualifiedJSXName(openingElement.name)\n          ) {\n            this.raise(JsxErrors.MissingClosingTagElement, {\n              at: closingElement,\n              openingTagName: getQualifiedJSXName(openingElement.name),\n            });\n          }\n        }\n      }\n\n      if (isFragment(openingElement)) {\n        node.openingFragment = openingElement;\n        node.closingFragment = closingElement;\n      } else {\n        node.openingElement = openingElement;\n        node.closingElement = closingElement;\n      }\n      node.children = children;\n      if (this.match(tt.lt)) {\n        throw this.raise(JsxErrors.UnwrappedAdjacentJSXElements, {\n          at: this.state.startLoc,\n        });\n      }\n\n      return isFragment(openingElement)\n        ? this.finishNode(node, \"JSXFragment\")\n        : this.finishNode(node, \"JSXElement\");\n    }\n\n    // Parses entire JSX element from current position.\n\n    jsxParseElement(): N.JSXElement {\n      const startLoc = this.state.startLoc;\n      this.next();\n      return this.jsxParseElementAt(startLoc);\n    }\n\n    setContext(newContext: TokContext) {\n      const { context } = this.state;\n      context[context.length - 1] = newContext;\n    }\n\n    // ==================================\n    // Overrides\n    // ==================================\n\n    parseExprAtom(refExpressionErrors?: ExpressionErrors | null): N.Expression {\n      if (this.match(tt.jsxText)) {\n        return this.parseLiteral(this.state.value, \"JSXText\");\n      } else if (this.match(tt.jsxTagStart)) {\n        return this.jsxParseElement();\n      } else if (\n        this.match(tt.lt) &&\n        this.input.charCodeAt(this.state.pos) !== charCodes.exclamationMark\n      ) {\n        // In case we encounter an lt token here it will always be the start of\n        // jsx as the lt sign is not allowed in places that expect an expression\n        this.replaceToken(tt.jsxTagStart);\n        return this.jsxParseElement();\n      } else {\n        return super.parseExprAtom(refExpressionErrors);\n      }\n    }\n\n    skipSpace() {\n      const curContext = this.curContext();\n      if (!curContext.preserveSpace) super.skipSpace();\n    }\n\n    getTokenFromCode(code: number): void {\n      const context = this.curContext();\n\n      if (context === tc.j_expr) {\n        this.jsxReadToken();\n        return;\n      }\n\n      if (context === tc.j_oTag || context === tc.j_cTag) {\n        if (isIdentifierStart(code)) {\n          this.jsxReadWord();\n          return;\n        }\n\n        if (code === charCodes.greaterThan) {\n          ++this.state.pos;\n          this.finishToken(tt.jsxTagEnd);\n          return;\n        }\n\n        if (\n          (code === charCodes.quotationMark || code === charCodes.apostrophe) &&\n          context === tc.j_oTag\n        ) {\n          this.jsxReadString(code);\n          return;\n        }\n      }\n\n      if (\n        code === charCodes.lessThan &&\n        this.state.canStartJSXElement &&\n        this.input.charCodeAt(this.state.pos + 1) !== charCodes.exclamationMark\n      ) {\n        ++this.state.pos;\n        this.finishToken(tt.jsxTagStart);\n        return;\n      }\n\n      super.getTokenFromCode(code);\n    }\n\n    updateContext(prevType: TokenType): void {\n      const { context, type } = this.state;\n      if (type === tt.slash && prevType === tt.jsxTagStart) {\n        // do not consider JSX expr -> JSX open tag -> ... anymore\n        // reconsider as closing tag context\n        context.splice(-2, 2, tc.j_cTag);\n        this.state.canStartJSXElement = false;\n      } else if (type === tt.jsxTagStart) {\n        // start opening tag context\n        context.push(tc.j_oTag);\n      } else if (type === tt.jsxTagEnd) {\n        const out = context[context.length - 1];\n        if ((out === tc.j_oTag && prevType === tt.slash) || out === tc.j_cTag) {\n          context.pop();\n          this.state.canStartJSXElement =\n            context[context.length - 1] === tc.j_expr;\n        } else {\n          this.setContext(tc.j_expr);\n          this.state.canStartJSXElement = true;\n        }\n      } else {\n        this.state.canStartJSXElement = tokenComesBeforeExpression(type);\n      }\n    }\n  };\n"],"mappings":"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"}��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������lib/plugins/jsx/xhtml.js����������������������������������������������������������������������������0000644�����������������00000011501�15120211212�0011252 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������"use strict";

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

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

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;
var _types = require("../tokenizer/types");
var _parseError = require("../parse-error");
const PlaceholderErrors = (0, _parseError.ParseErrorEnum)`placeholders`({
  ClassNameIsRequired: "A class name is required.",
  UnexpectedSpace: "Unexpected space in placeholder."
});
var _default = superClass => class PlaceholdersParserMixin extends superClass {
  parsePlaceholder(expectedNode) {
    if (this.match(142)) {
      const node = this.startNode();
      this.next();
      this.assertNoSpace();
      node.name = super.parseIdentifier(true);
      this.assertNoSpace();
      this.expect(142);
      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) {
      this.finishOp(142, 2);
    } else {
      super.getTokenFromCode(code);
    }
  }
  parseExprAtom(refExpressionErrors) {
    return this.parsePlaceholder("Expression") || super.parseExprAtom(refExpressionErrors);
  }
  parseIdentifier(liberal) {
    return this.parsePlaceholder("Identifier") || super.parseIdentifier(liberal);
  }
  checkReservedWord(word, startLoc, checkKeywords, isBinding) {
    if (word !== undefined) {
      super.checkReservedWord(word, startLoc, checkKeywords, isBinding);
    }
  }
  parseBindingAtom() {
    return this.parsePlaceholder("Pattern") || super.parseBindingAtom();
  }
  isValidLVal(type, isParenthesized, binding) {
    return type === "Placeholder" || super.isValidLVal(type, isParenthesized, binding);
  }
  toAssignable(node, isLHS) {
    if (node && node.type === "Placeholder" && node.expectedNode === "Expression") {
      node.expectedNode = "Pattern";
    } else {
      super.toAssignable(node, isLHS);
    }
  }
  chStartsBindingIdentifier(ch, pos) {
    if (super.chStartsBindingIdentifier(ch, pos)) {
      return true;
    }
    const nextToken = this.lookahead();
    if (nextToken.type === 142) {
      return true;
    }
    return false;
  }
  verifyBreakContinue(node, isBreak) {
    if (node.label && node.label.type === "Placeholder") return;
    super.verifyBreakContinue(node, isBreak);
  }
  parseExpressionStatement(node, expr) {
    if (expr.type !== "Placeholder" || expr.extra && expr.extra.parenthesized) {
      return super.parseExpressionStatement(node, expr);
    }
    if (this.match(14)) {
      const stmt = node;
      stmt.label = this.finishPlaceholder(expr, "Identifier");
      this.next();
      stmt.body = super.parseStatementOrSloppyAnnexBFunctionDeclaration();
      return this.finishNode(stmt, "LabeledStatement");
    }
    this.semicolon();
    node.name = expr.name;
    return this.finishPlaceholder(node, "Statement");
  }
  parseBlock(allowDirectives, createNewLexicalScope, afterBlockParse) {
    return this.parsePlaceholder("BlockStatement") || super.parseBlock(allowDirectives, createNewLexicalScope, afterBlockParse);
  }
  parseFunctionId(requireId) {
    return this.parsePlaceholder("Identifier") || super.parseFunctionId(requireId);
  }
  parseClass(node, isStatement, optionalId) {
    const type = isStatement ? "ClassDeclaration" : "ClassExpression";
    this.next();
    const oldStrict = this.state.strict;
    const placeholder = this.parsePlaceholder("Identifier");
    if (placeholder) {
      if (this.match(81) || this.match(142) || 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);
    }
    super.parseClassSuper(node);
    node.body = this.parsePlaceholder("ClassBody") || super.parseClassBody(!!node.superClass, oldStrict);
    return this.finishNode(node, type);
  }
  parseExport(node, decorators) {
    const placeholder = this.parsePlaceholder("Identifier");
    if (!placeholder) return super.parseExport(node, decorators);
    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, decorators);
  }
  isExportDefaultSpecifier() {
    if (this.match(65)) {
      const next = this.nextTokenStart();
      if (this.isUnparsedContextual(next, "from")) {
        if (this.input.startsWith((0, _types.tokenLabelName)(142), this.nextTokenStartSince(next + 4))) {
          return true;
        }
      }
    }
    return super.isExportDefaultSpecifier();
  }
  maybeParseExportDefaultSpecifier(node, maybeDefaultIdentifier) {
    var _specifiers;
    if ((_specifiers = node.specifiers) != null && _specifiers.length) {
      return true;
    }
    return super.maybeParseExportDefaultSpecifier(node, maybeDefaultIdentifier);
  }
  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(node);
    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;
    node.specifiers.push(this.finishNode(specifier, "ImportDefaultSpecifier"));
    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();
  }
  assertNoSpace() {
    if (this.state.start > this.state.lastTokEndLoc.index) {
      this.raise(PlaceholderErrors.UnexpectedSpace, {
        at: this.state.lastTokEndLoc
      });
    }
  }
};
exports.default = _default;

//# sourceMappingURL=placeholders.js.map
����������������������������������������������������������������������������lib/plugins/placeholders.js.map���������������������������������������������������������������������0000644�����������������00000054013�15120211212�0012540 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������{"version":3,"names":["_types","require","_parseError","PlaceholderErrors","ParseErrorEnum","ClassNameIsRequired","UnexpectedSpace","_default","superClass","PlaceholdersParserMixin","parsePlaceholder","expectedNode","match","node","startNode","next","assertNoSpace","name","parseIdentifier","expect","finishPlaceholder","isFinished","type","finishNode","getTokenFromCode","code","input","charCodeAt","state","pos","finishOp","parseExprAtom","refExpressionErrors","liberal","checkReservedWord","word","startLoc","checkKeywords","isBinding","undefined","parseBindingAtom","isValidLVal","isParenthesized","binding","toAssignable","isLHS","chStartsBindingIdentifier","ch","nextToken","lookahead","verifyBreakContinue","isBreak","label","parseExpressionStatement","expr","extra","parenthesized","stmt","body","parseStatementOrSloppyAnnexBFunctionDeclaration","semicolon","parseBlock","allowDirectives","createNewLexicalScope","afterBlockParse","parseFunctionId","requireId","parseClass","isStatement","optionalId","oldStrict","strict","placeholder","id","raise","at","parseClassId","parseClassSuper","parseClassBody","parseExport","decorators","isContextual","specifiers","source","declaration","expectPlugin","specifier","exported","isExportDefaultSpecifier","nextTokenStart","isUnparsedContextual","startsWith","tokenLabelName","nextTokenStartSince","maybeParseExportDefaultSpecifier","maybeDefaultIdentifier","_specifiers","length","checkExport","filter","parseImport","startNodeAtNode","local","push","eat","hasStarImport","maybeParseStarImportSpecifier","parseNamedImportSpecifiers","expectContextual","parseImportSource","start","lastTokEndLoc","index","exports","default"],"sources":["../../src/plugins/placeholders.ts"],"sourcesContent":["import * as charCodes from \"charcodes\";\n\nimport { tokenLabelName, tt } from \"../tokenizer/types\";\nimport type Parser from \"../parser\";\nimport type * as N from \"../types\";\nimport { ParseErrorEnum } from \"../parse-error\";\nimport type { Undone } from \"../parser/node\";\nimport type { ExpressionErrors } from \"../parser/util\";\nimport type { BindingTypes } from \"../util/scopeflags\";\nimport type { Position } from \"../util/location\";\n\ntype PossiblePlaceholders = {\n  Identifier: N.Identifier;\n  StringLiteral: N.StringLiteral;\n  Expression: N.Expression;\n  Statement: N.Statement;\n  Declaration: N.Declaration;\n  BlockStatement: N.BlockStatement;\n  ClassBody: N.ClassBody;\n  Pattern: N.Pattern;\n};\nexport type PlaceholderTypes = keyof PossiblePlaceholders;\n\ntype NodeOf<T extends keyof PossiblePlaceholders> = PossiblePlaceholders[T];\n// todo: when there  is proper union type for Node\n// type NodeOf<T extends PlaceholderTypes> = Extract<N.Node, { type: T }>;\n\n// todo: Placeholder<T> breaks everything, because its type is incompatible with\n// the substituted nodes.\ntype MaybePlaceholder<T extends PlaceholderTypes> = NodeOf<T>; // | Placeholder<T>\n\n/* eslint sort-keys: \"error\" */\nconst PlaceholderErrors = ParseErrorEnum`placeholders`({\n  ClassNameIsRequired: \"A class name is required.\",\n  UnexpectedSpace: \"Unexpected space in placeholder.\",\n});\n\n/* eslint-disable sort-keys */\n\nexport default (superClass: typeof Parser) =>\n  class PlaceholdersParserMixin extends superClass implements Parser {\n    parsePlaceholder<T extends PlaceholderTypes>(\n      expectedNode: T,\n    ): /*?N.Placeholder<T>*/ MaybePlaceholder<T> | undefined | null {\n      if (this.match(tt.placeholder)) {\n        const node = this.startNode();\n        this.next();\n        this.assertNoSpace();\n\n        // We can't use this.parseIdentifier because\n        // we don't want nested placeholders.\n        node.name = super.parseIdentifier(/* liberal */ true);\n\n        this.assertNoSpace();\n        this.expect(tt.placeholder);\n        // @ts-expect-error placeholder typings\n        return this.finishPlaceholder(node, expectedNode);\n      }\n    }\n\n    finishPlaceholder<T extends PlaceholderTypes>(\n      node: N.Node,\n      expectedNode: T,\n    ): /*N.Placeholder<T>*/ MaybePlaceholder<T> {\n      const isFinished = !!(node.expectedNode && node.type === \"Placeholder\");\n      node.expectedNode = expectedNode;\n\n      // @ts-expect-error todo(flow->ts)\n      return isFinished ? node : this.finishNode(node, \"Placeholder\");\n    }\n\n    /* ============================================================ *\n     * tokenizer/index.js                                           *\n     * ============================================================ */\n\n    getTokenFromCode(code: number) {\n      if (\n        code === charCodes.percentSign &&\n        this.input.charCodeAt(this.state.pos + 1) === charCodes.percentSign\n      ) {\n        this.finishOp(tt.placeholder, 2);\n      } else {\n        super.getTokenFromCode(code);\n      }\n    }\n\n    /* ============================================================ *\n     * parser/expression.js                                         *\n     * ============================================================ */\n\n    parseExprAtom(\n      refExpressionErrors?: ExpressionErrors | null,\n    ): MaybePlaceholder<\"Expression\"> {\n      return (\n        this.parsePlaceholder(\"Expression\") ||\n        super.parseExprAtom(refExpressionErrors)\n      );\n    }\n\n    parseIdentifier(liberal?: boolean): MaybePlaceholder<\"Identifier\"> {\n      // NOTE: This function only handles identifiers outside of\n      // expressions and binding patterns, since they are already\n      // handled by the parseExprAtom and parseBindingAtom functions.\n      // This is needed, for example, to parse \"class %%NAME%% {}\".\n      return (\n        this.parsePlaceholder(\"Identifier\") || super.parseIdentifier(liberal)\n      );\n    }\n\n    checkReservedWord(\n      word: string,\n      startLoc: Position,\n      checkKeywords: boolean,\n      isBinding: boolean,\n    ) {\n      // Sometimes we call #checkReservedWord(node.name), expecting\n      // that node is an Identifier. If it is a Placeholder, name\n      // will be undefined.\n      if (word !== undefined) {\n        super.checkReservedWord(word, startLoc, checkKeywords, isBinding);\n      }\n    }\n\n    /* ============================================================ *\n     * parser/lval.js                                               *\n     * ============================================================ */\n\n    parseBindingAtom(): MaybePlaceholder<\"Pattern\"> {\n      return this.parsePlaceholder(\"Pattern\") || super.parseBindingAtom();\n    }\n\n    isValidLVal(type: string, isParenthesized: boolean, binding: BindingTypes) {\n      return (\n        type === \"Placeholder\" ||\n        super.isValidLVal(type, isParenthesized, binding)\n      );\n    }\n\n    toAssignable(node: N.Node, isLHS: boolean): void {\n      if (\n        node &&\n        node.type === \"Placeholder\" &&\n        node.expectedNode === \"Expression\"\n      ) {\n        node.expectedNode = \"Pattern\";\n      } else {\n        super.toAssignable(node, isLHS);\n      }\n    }\n\n    /* ============================================================ *\n     * parser/statement.js                                          *\n     * ============================================================ */\n\n    chStartsBindingIdentifier(ch: number, pos: number): boolean {\n      if (super.chStartsBindingIdentifier(ch, pos)) {\n        return true;\n      }\n\n      // Accept \"let %%\" as the start of \"let %%placeholder%%\", as though the\n      // placeholder were an identifier.\n      const nextToken = this.lookahead();\n      if (nextToken.type === tt.placeholder) {\n        return true;\n      }\n\n      return false;\n    }\n\n    verifyBreakContinue(\n      node: N.BreakStatement | N.ContinueStatement,\n      isBreak: boolean,\n    ) {\n      // @ts-expect-error: node.label could be Placeholder\n      if (node.label && node.label.type === \"Placeholder\") return;\n      super.verifyBreakContinue(node, isBreak);\n    }\n\n    // @ts-expect-error Plugin will override parser interface\n    parseExpressionStatement(\n      node: MaybePlaceholder<\"Statement\">,\n      expr: N.Expression,\n    ): MaybePlaceholder<\"Statement\"> {\n      if (\n        expr.type !== \"Placeholder\" ||\n        (expr.extra && expr.extra.parenthesized)\n      ) {\n        // @ts-expect-error placeholder typings\n        return super.parseExpressionStatement(node, expr);\n      }\n\n      if (this.match(tt.colon)) {\n        // @ts-expect-error placeholder typings\n        const stmt: N.LabeledStatement = node;\n        stmt.label = this.finishPlaceholder(expr, \"Identifier\");\n        this.next();\n        stmt.body = super.parseStatementOrSloppyAnnexBFunctionDeclaration();\n        return this.finishNode(stmt, \"LabeledStatement\");\n      }\n\n      this.semicolon();\n      node.name = expr.name;\n      return this.finishPlaceholder(node, \"Statement\");\n    }\n\n    parseBlock(\n      allowDirectives?: boolean,\n      createNewLexicalScope?: boolean,\n      afterBlockParse?: (hasStrictModeDirective: boolean) => void,\n    ): MaybePlaceholder<\"BlockStatement\"> {\n      return (\n        this.parsePlaceholder(\"BlockStatement\") ||\n        super.parseBlock(\n          allowDirectives,\n          createNewLexicalScope,\n          afterBlockParse,\n        )\n      );\n    }\n\n    parseFunctionId(\n      requireId?: boolean,\n    ): MaybePlaceholder<\"Identifier\"> | undefined | null {\n      return (\n        this.parsePlaceholder(\"Identifier\") || super.parseFunctionId(requireId)\n      );\n    }\n    // @ts-expect-error Plugin will override parser interface\n    parseClass<T extends N.Class>(\n      node: T,\n      isStatement: /* T === ClassDeclaration */ boolean,\n      optionalId?: boolean,\n    ): T {\n      const type = isStatement ? \"ClassDeclaration\" : \"ClassExpression\";\n\n      this.next();\n      const oldStrict = this.state.strict;\n\n      const placeholder = this.parsePlaceholder(\"Identifier\");\n      if (placeholder) {\n        if (\n          this.match(tt._extends) ||\n          this.match(tt.placeholder) ||\n          this.match(tt.braceL)\n        ) {\n          node.id = placeholder;\n        } else if (optionalId || !isStatement) {\n          node.id = null;\n          node.body = this.finishPlaceholder(placeholder, \"ClassBody\");\n          return this.finishNode(node, type);\n        } else {\n          throw this.raise(PlaceholderErrors.ClassNameIsRequired, {\n            at: this.state.startLoc,\n          });\n        }\n      } else {\n        this.parseClassId(node, isStatement, optionalId);\n      }\n\n      super.parseClassSuper(node);\n      node.body =\n        this.parsePlaceholder(\"ClassBody\") ||\n        super.parseClassBody(!!node.superClass, oldStrict);\n      return this.finishNode(node, type);\n    }\n\n    parseExport(node: N.Node, decorators: N.Decorator[] | null): N.AnyExport {\n      const placeholder = this.parsePlaceholder(\"Identifier\");\n      if (!placeholder) return super.parseExport(node, decorators);\n\n      if (!this.isContextual(tt._from) && !this.match(tt.comma)) {\n        // export %%DECL%%;\n        node.specifiers = [];\n        node.source = null;\n        node.declaration = this.finishPlaceholder(placeholder, \"Declaration\");\n        return this.finishNode(node, \"ExportNamedDeclaration\");\n      }\n\n      // export %%NAME%% from \"foo\";\n      this.expectPlugin(\"exportDefaultFrom\");\n      const specifier = this.startNode();\n      specifier.exported = placeholder;\n      node.specifiers = [this.finishNode(specifier, \"ExportDefaultSpecifier\")];\n\n      return super.parseExport(node, decorators);\n    }\n\n    isExportDefaultSpecifier(): boolean {\n      if (this.match(tt._default)) {\n        const next = this.nextTokenStart();\n        if (this.isUnparsedContextual(next, \"from\")) {\n          if (\n            this.input.startsWith(\n              tokenLabelName(tt.placeholder),\n              this.nextTokenStartSince(next + 4),\n            )\n          ) {\n            return true;\n          }\n        }\n      }\n      return super.isExportDefaultSpecifier();\n    }\n\n    maybeParseExportDefaultSpecifier(\n      node: Undone<\n        | N.ExportDefaultDeclaration\n        | N.ExportAllDeclaration\n        | N.ExportNamedDeclaration\n      >,\n      maybeDefaultIdentifier: N.Identifier | null,\n    ): node is Undone<N.ExportNamedDeclaration> {\n      if ((node as N.ExportNamedDeclaration).specifiers?.length) {\n        // \"export %%NAME%%\" has already been parsed by #parseExport.\n        return true;\n      }\n      return super.maybeParseExportDefaultSpecifier(\n        node,\n        maybeDefaultIdentifier,\n      );\n    }\n\n    checkExport(node: N.ExportNamedDeclaration): void {\n      const { specifiers } = node;\n      if (specifiers?.length) {\n        node.specifiers = specifiers.filter(\n          // @ts-expect-error placeholder typings\n          node => node.exported.type === \"Placeholder\",\n        );\n      }\n      super.checkExport(node);\n      node.specifiers = specifiers;\n    }\n\n    parseImport(\n      node: Undone<N.ImportDeclaration>,\n    ): N.ImportDeclaration | N.TsImportEqualsDeclaration {\n      const placeholder = this.parsePlaceholder(\"Identifier\");\n      if (!placeholder) return super.parseImport(node);\n\n      node.specifiers = [];\n\n      if (!this.isContextual(tt._from) && !this.match(tt.comma)) {\n        // import %%STRING%%;\n        node.source = this.finishPlaceholder(placeholder, \"StringLiteral\");\n        this.semicolon();\n        return this.finishNode(node, \"ImportDeclaration\");\n      }\n\n      // import %%DEFAULT%% ...\n      const specifier =\n        this.startNodeAtNode<N.ImportDefaultSpecifier>(placeholder);\n      specifier.local = placeholder;\n      node.specifiers.push(\n        this.finishNode(specifier, \"ImportDefaultSpecifier\"),\n      );\n\n      if (this.eat(tt.comma)) {\n        // import %%DEFAULT%%, * as ...\n        const hasStarImport = this.maybeParseStarImportSpecifier(node);\n\n        // import %%DEFAULT%%, { ...\n        if (!hasStarImport) this.parseNamedImportSpecifiers(node);\n      }\n\n      this.expectContextual(tt._from);\n      node.source = this.parseImportSource();\n      this.semicolon();\n      return this.finishNode(node, \"ImportDeclaration\");\n    }\n\n    parseImportSource(): MaybePlaceholder<\"StringLiteral\"> {\n      // import ... from %%STRING%%;\n\n      return (\n        this.parsePlaceholder(\"StringLiteral\") || super.parseImportSource()\n      );\n    }\n\n    // Throws if the current token and the prev one are separated by a space.\n    assertNoSpace(): void {\n      if (this.state.start > this.state.lastTokEndLoc.index) {\n        this.raise(PlaceholderErrors.UnexpectedSpace, {\n          at: this.state.lastTokEndLoc,\n        });\n      }\n    }\n  };\n"],"mappings":"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"}���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������lib/plugins/typescript/index.js���������������������������������������������������������������������0000644�����������������00000271047�15120211212�0012644 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;
var _types = require("../../tokenizer/types");
var _context = require("../../tokenizer/context");
var _location = require("../../util/location");
var _scopeflags = require("../../util/scopeflags");
var _scope = require("./scope");
var _productionParameter = require("../../util/production-parameter");
var _parseError = require("../../parse-error");
var _node = require("../../parser/node");
var _lval = require("../../parser/lval");
const getOwn = (object, key) => Object.hasOwnProperty.call(object, key) && object[key];
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 = (0, _parseError.ParseErrorEnum)`typescript`({
  AbstractMethodHasImplementation: ({
    methodName
  }) => `Method '${methodName}' cannot have an implementation because it is marked abstract.`,
  AbstractPropertyHasInitializer: ({
    propertyName
  }) => `Property '${propertyName}' 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.",
  AccessorCannotBeOptional: "An 'accessor' property cannot be declared optional.",
  ClassMethodHasDeclare: "Class methods cannot have the 'declare' modifier.",
  ClassMethodHasReadonly: "Class methods cannot have the 'readonly' modifier.",
  ConstInitiailizerMustBeStringOrNumericLiteralOrLiteralEnumReference: "A 'const' initializer in an ambient context must be a string or numeric literal or literal enum reference.",
  ConstructorHasTypeParameters: "Type parameters cannot appear on a constructor declaration.",
  DeclareAccessor: ({
    kind
  }) => `'declare' is not allowed in ${kind}ters.`,
  DeclareClassFieldHasInitializer: "Initializers are not allowed in ambient contexts.",
  DeclareFunctionHasImplementation: "An implementation cannot be declared in ambient contexts.",
  DuplicateAccessibilityModifier: ({
    modifier
  }) => `Accessibility modifier already seen.`,
  DuplicateModifier: ({
    modifier
  }) => `Duplicate modifier: '${modifier}'.`,
  EmptyHeritageClauseType: ({
    token
  }) => `'${token}' 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'.",
  ImportReflectionHasImportType: "An `import module` declaration can not use `type` modifier",
  IncompatibleModifiers: ({
    modifiers
  }) => `'${modifiers[0]}' modifier cannot be used with '${modifiers[1]}' modifier.`,
  IndexSignatureHasAbstract: "Index signatures cannot have the 'abstract' modifier.",
  IndexSignatureHasAccessibility: ({
    modifier
  }) => `Index signatures cannot have an accessibility modifier ('${modifier}').`,
  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.",
  InitializerNotAllowedInAmbientContext: "Initializers are not allowed in ambient contexts.",
  InvalidModifierOnTypeMember: ({
    modifier
  }) => `'${modifier}' modifier cannot appear on a type member.`,
  InvalidModifierOnTypeParameter: ({
    modifier
  }) => `'${modifier}' modifier cannot appear on a type parameter.`,
  InvalidModifierOnTypeParameterPositions: ({
    modifier
  }) => `'${modifier}' modifier can only appear on a type parameter of a class, interface or type alias.`,
  InvalidModifiersOrder: ({
    orderedModifiers
  }) => `'${orderedModifiers[0]}' modifier must precede '${orderedModifiers[1]}' modifier.`,
  InvalidPropertyAccessAfterInstantiationExpression: "Invalid property access after an instantiation expression. " + "You can either wrap the instantiation expression in parentheses, or delete the type arguments.",
  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: ({
    modifier
  }) => `Private elements cannot have an accessibility modifier ('${modifier}').`,
  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 `<T,>() => ...`.",
  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.",
  SingleTypeParameterWithoutTrailingComma: ({
    typeParameterName
  }) => `Single type parameter ${typeParameterName} should have a trailing comma. Example usage: <${typeParameterName},>.`,
  StaticBlockCannotHaveModifier: "Static class blocks cannot have any modifier.",
  TupleOptionalAfterType: "A labeled tuple optional element must be declared using a question mark after the name and before the colon (`name?: type`), rather than after the type (`name: type?`).",
  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: ({
    type
  }) => `Name in a signature must be an Identifier, ObjectPattern or ArrayPattern, instead got ${type}.`
});
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";
}
function tsIsVarianceAnnotations(modifier) {
  return modifier === "in" || modifier === "out";
}
var _default = superClass => class TypeScriptParserMixin extends superClass {
  constructor(...args) {
    super(...args);
    this.tsParseInOutModifiers = this.tsParseModifiers.bind(this, {
      allowedModifiers: ["in", "out"],
      disallowedModifiers: ["const", "public", "private", "protected", "readonly", "declare", "abstract", "override"],
      errorTemplate: TSErrors.InvalidModifierOnTypeParameter
    });
    this.tsParseConstModifier = this.tsParseModifiers.bind(this, {
      allowedModifiers: ["const"],
      disallowedModifiers: ["in", "out"],
      errorTemplate: TSErrors.InvalidModifierOnTypeParameterPositions
    });
    this.tsParseInOutConstModifiers = this.tsParseModifiers.bind(this, {
      allowedModifiers: ["in", "out", "const"],
      disallowedModifiers: ["public", "private", "protected", "readonly", "declare", "abstract", "override"],
      errorTemplate: TSErrors.InvalidModifierOnTypeParameter
    });
  }
  getScopeHandler() {
    return _scope.default;
  }
  tsIsIdentifier() {
    return (0, _types.tokenIsIdentifier)(this.state.type);
  }
  tsTokenCanFollowModifier() {
    return (this.match(0) || this.match(5) || this.match(55) || this.match(21) || this.match(136) || this.isLiteralPropertyName()) && !this.hasPrecedingLineBreak();
  }
  tsNextTokenCanFollowModifier() {
    this.next();
    return this.tsTokenCanFollowModifier();
  }
  tsParseModifier(allowedModifiers, stopOnStartOfClassStaticBlock) {
    if (!(0, _types.tokenIsIdentifier)(this.state.type) && this.state.type !== 58 && this.state.type !== 75) {
      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({
    allowedModifiers,
    disallowedModifiers,
    stopOnStartOfClassStaticBlock,
    errorTemplate = TSErrors.InvalidModifierOnTypeMember
  }, modified) {
    const enforceOrder = (loc, modifier, before, after) => {
      if (modifier === before && modified[after]) {
        this.raise(TSErrors.InvalidModifiersOrder, {
          at: loc,
          orderedModifiers: [before, after]
        });
      }
    };
    const incompatible = (loc, modifier, mod1, mod2) => {
      if (modified[mod1] && modifier === mod2 || modified[mod2] && modifier === mod1) {
        this.raise(TSErrors.IncompatibleModifiers, {
          at: loc,
          modifiers: [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,
            modifier
          });
        } else {
          enforceOrder(startLoc, modifier, modifier, "override");
          enforceOrder(startLoc, modifier, modifier, "static");
          enforceOrder(startLoc, modifier, modifier, "readonly");
          modified.accessibility = modifier;
        }
      } else if (tsIsVarianceAnnotations(modifier)) {
        if (modified[modifier]) {
          this.raise(TSErrors.DuplicateModifier, {
            at: startLoc,
            modifier
          });
        }
        modified[modifier] = true;
        enforceOrder(startLoc, modifier, "in", "out");
      } 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);
    }
  }
  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(131)) {
      this.raise(TSErrors.UnsupportedImportTypeArgument, {
        at: this.state.startLoc
      });
    }
    node.argument = super.parseExprAtom();
    this.expect(11);
    if (this.eat(16)) {
      node.qualifier = this.tsParseEntityName();
    }
    if (this.match(47)) {
      node.typeParameters = this.tsParseTypeArguments();
    }
    return this.finishNode(node, "TSImportType");
  }
  tsParseEntityName(allowReservedWords = true) {
    let entity = this.parseIdentifier(allowReservedWords);
    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();
    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();
    }
    if (!this.hasPrecedingLineBreak() && this.match(47)) {
      node.typeParameters = this.tsParseTypeArguments();
    }
    return this.finishNode(node, "TSTypeQuery");
  }
  tsParseTypeParameter(parseModifiers) {
    const node = this.startNode();
    parseModifiers(node);
    node.name = this.tsParseTypeParameterName();
    node.constraint = this.tsEatThenParseType(81);
    node.default = this.tsEatThenParseType(29);
    return this.finishNode(node, "TSTypeParameter");
  }
  tsTryParseTypeParameters(parseModifiers) {
    if (this.match(47)) {
      return this.tsParseTypeParameters(parseModifiers);
    }
  }
  tsParseTypeParameters(parseModifiers) {
    const node = this.startNode();
    if (this.match(47) || this.match(140)) {
      this.next();
    } else {
      this.unexpected();
    }
    const refTrailingCommaPos = {
      value: -1
    };
    node.params = this.tsParseBracketedList("TypeParametersOrArguments", this.tsParseTypeParameter.bind(this, parseModifiers), false, true, refTrailingCommaPos);
    if (node.params.length === 0) {
      this.raise(TSErrors.EmptyTypeParameters, {
        at: node
      });
    }
    if (refTrailingCommaPos.value !== -1) {
      this.addExtra(node, "trailingComma", refTrailingCommaPos.value);
    }
    return this.finishNode(node, "TSTypeParameterDeclaration");
  }
  tsFillSignature(returnToken, signature) {
    const returnTokenRequired = returnToken === 19;
    const paramsKey = "parameters";
    const returnTypeKey = "typeAnnotation";
    signature.typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier);
    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() {
    const list = super.parseBindingList(11, 41, _lval.ParseBindingListFlags.IS_FUNCTION_PARAMS);
    for (const pattern of list) {
      const {
        type
      } = pattern;
      if (type === "AssignmentPattern" || type === "TSParameterProperty") {
        this.raise(TSErrors.UnsupportedSignatureParameterKind, {
          at: pattern,
          type
        });
      }
    }
    return list;
  }
  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 ((0, _types.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;
    }
    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, {
          at: 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(_parseError.Errors.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(_parseError.Errors.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, {
            at: 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({
      allowedModifiers: ["readonly"],
      disallowedModifiers: ["declare", "abstract", "private", "protected", "public", "static", "override"]
    }, node);
    const idx = this.tsTryParseIndexSignature(node);
    if (idx) {
      return idx;
    }
    super.parsePropertyName(node);
    if (!node.computed && node.key.type === "Identifier" && (node.key.name === "get" || node.key.name === "set") && this.tsTokenCanFollowModifier()) {
      node.kind = node.key.name;
      super.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(120);
    }
    if (this.isContextual(120)) {
      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(120);
    } else if (this.eatContextual(120)) {
      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;
      const {
        type
      } = elementNode;
      if (seenOptionalElement && type !== "TSRestType" && type !== "TSOptionalType" && !(type === "TSNamedTupleMember" && elementNode.optional)) {
        this.raise(TSErrors.OptionalTypeBeforeRequired, {
          at: elementNode
        });
      }
      seenOptionalElement || (seenOptionalElement = type === "TSNamedTupleMember" && elementNode.optional || type === "TSOptionalType");
      let checkType = type;
      if (type === "TSRestType") {
        elementNode = elementNode.typeAnnotation;
        checkType = elementNode.type;
      }
      const isLabeled = checkType === "TSNamedTupleMember";
      (_labeledElements = labeledElements) != null ? _labeledElements : labeledElements = isLabeled;
      if (labeledElements !== isLabeled) {
        this.raise(TSErrors.MixedLabeledAndUnlabeledElements, {
          at: elementNode
        });
      }
    });
    return this.finishNode(node, "TSTupleType");
  }
  tsParseTupleElementType() {
    const {
      startLoc
    } = this.state;
    const rest = this.eat(21);
    let labeled;
    let label;
    let optional;
    let type;
    const isWord = (0, _types.tokenIsKeywordOrIdentifier)(this.state.type);
    const chAfterWord = isWord ? this.lookaheadCharCode() : null;
    if (chAfterWord === 58) {
      labeled = true;
      optional = false;
      label = this.parseIdentifier(true);
      this.expect(14);
      type = this.tsParseType();
    } else if (chAfterWord === 63) {
      optional = true;
      const startLoc = this.state.startLoc;
      const wordName = this.state.value;
      const typeOrLabel = this.tsParseNonArrayType();
      if (this.lookaheadCharCode() === 58) {
        labeled = true;
        label = this.createIdentifier(this.startNodeAt(startLoc), wordName);
        this.expect(17);
        this.expect(14);
        type = this.tsParseType();
      } else {
        labeled = false;
        type = typeOrLabel;
        this.expect(17);
      }
    } else {
      type = this.tsParseType();
      optional = this.eat(17);
      labeled = this.eat(14);
    }
    if (labeled) {
      let labeledNode;
      if (label) {
        labeledNode = this.startNodeAtNode(label);
        labeledNode.optional = optional;
        labeledNode.label = label;
        labeledNode.elementType = type;
        if (this.eat(17)) {
          labeledNode.optional = true;
          this.raise(TSErrors.TupleOptionalAfterType, {
            at: this.state.lastTokStartLoc
          });
        }
      } else {
        labeledNode = this.startNodeAtNode(type);
        labeledNode.optional = optional;
        this.raise(TSErrors.InvalidTupleMemberLabel, {
          at: 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(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.tsInAllowConditionalTypesContext(() => this.tsFillSignature(19, node));
    return this.finishNode(node, type);
  }
  tsParseLiteralTypeNode() {
    const node = this.startNode();
    switch (this.state.type) {
      case 132:
      case 133:
      case 131:
      case 85:
      case 86:
        node.literal = super.parseExprAtom();
        break;
      default:
        this.unexpected();
    }
    return this.finishNode(node, "TSLiteralType");
  }
  tsParseTemplateLiteralType() {
    const node = this.startNode();
    node.literal = super.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(114) && !this.hasPrecedingLineBreak()) {
      return this.tsParseThisTypePredicate(thisKeyword);
    } else {
      return thisKeyword;
    }
  }
  tsParseNonArrayType() {
    switch (this.state.type) {
      case 131:
      case 132:
      case 133:
      case 85:
      case 86:
        return this.tsParseLiteralTypeNode();
      case 53:
        if (this.state.value === "-") {
          const node = this.startNode();
          const nextToken = this.lookahead();
          if (nextToken.type !== 132 && nextToken.type !== 133) {
            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 ((0, _types.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();
          }
        }
    }
    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, {
          at: node
        });
    }
  }
  tsParseInferType() {
    const node = this.startNode();
    this.expectContextual(113);
    const typeParameter = this.startNode();
    typeParameter.name = this.tsParseTypeParameterName();
    typeParameter.constraint = this.tsTryParse(() => this.tsParseConstraintForInferType());
    node.typeParameter = this.finishNode(typeParameter, "TSTypeParameter");
    return this.finishNode(node, "TSInferType");
  }
  tsParseConstraintForInferType() {
    if (this.eat(81)) {
      const constraint = this.tsInDisallowConditionalTypesContext(() => this.tsParseType());
      if (this.state.inDisallowConditionalTypesContext || !this.match(17)) {
        return constraint;
      }
    }
  }
  tsParseTypeOperatorOrHigher() {
    const isTypeOperator = (0, _types.tokenIsTSTypeOperator)(this.state.type) && !this.state.containsEsc;
    return isTypeOperator ? this.tsParseTypeOperator() : this.isContextual(113) ? this.tsParseInferType() : this.tsInAllowConditionalTypesContext(() => 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 ((0, _types.tokenIsIdentifier)(this.state.type) || this.match(78)) {
      this.next();
      return true;
    }
    if (this.match(5)) {
      const {
        errors
      } = this.state;
      const previousErrorCount = errors.length;
      try {
        this.parseObjectLike(8, true);
        return errors.length === previousErrorCount;
      } catch (_unused) {
        return false;
      }
    }
    if (this.match(0)) {
      this.next();
      const {
        errors
      } = this.state;
      const previousErrorCount = errors.length;
      try {
        super.parseBindingList(3, 93, _lval.ParseBindingListFlags.ALLOW_EMPTY);
        return errors.length === previousErrorCount;
      } catch (_unused2) {
        return false;
      }
    }
    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() {
    if (this.match(14)) {
      return this.tsParseTypeOrTypePredicateAnnotation(14);
    }
  }
  tsTryParseTypeAnnotation() {
    if (this.match(14)) {
      return this.tsParseTypeAnnotation();
    }
  }
  tsTryParseType() {
    return this.tsEatThenParseType(14);
  }
  tsParseTypePredicatePrefix() {
    const id = this.parseIdentifier();
    if (this.isContextual(114) && !this.hasPrecedingLineBreak()) {
      this.next();
      return id;
    }
  }
  tsParseTypePredicateAsserts() {
    if (this.state.type !== 107) {
      return false;
    }
    const containsEsc = this.state.containsEsc;
    this.next();
    if (!(0, _types.tokenIsIdentifier)(this.state.type) && !this.match(78)) {
      return false;
    }
    if (containsEsc) {
      this.raise(_parseError.Errors.InvalidEscapedReservedWord, {
        at: this.state.lastTokStartLoc,
        reservedWord: "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.state.inDisallowConditionalTypesContext || this.hasPrecedingLineBreak() || !this.eat(81)) {
      return type;
    }
    const node = this.startNodeAtNode(type);
    node.checkType = type;
    node.extendsType = this.tsInDisallowConditionalTypesContext(() => this.tsParseNonConditionalType());
    this.expect(17);
    node.trueType = this.tsInAllowConditionalTypesContext(() => this.tsParseType());
    this.expect(14);
    node.falseType = this.tsInAllowConditionalTypesContext(() => this.tsParseType());
    return this.finishNode(node, "TSConditionalType");
  }
  isAbstractConstructorSignature() {
    return this.isContextual(122) && 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();
    node.typeAnnotation = this.tsInType(() => {
      this.next();
      return this.match(75) ? this.tsParseTypeReference() : this.tsParseType();
    });
    this.expect(48);
    node.expression = this.parseMaybeUnary();
    return this.finishNode(node, "TSTypeAssertion");
  }
  tsParseHeritageClause(token) {
    const originalStartLoc = this.state.startLoc;
    const delimitedList = this.tsParseDelimitedList("HeritageClauseElement", () => {
      const node = this.startNode();
      node.expression = this.tsParseEntityName();
      if (this.match(47)) {
        node.typeParameters = this.tsParseTypeArguments();
      }
      return this.finishNode(node, "TSExpressionWithTypeArguments");
    });
    if (!delimitedList.length) {
      this.raise(TSErrors.EmptyHeritageClauseType, {
        at: originalStartLoc,
        token
      });
    }
    return delimitedList;
  }
  tsParseInterfaceDeclaration(node, properties = {}) {
    if (this.hasFollowingLineBreak()) return null;
    this.expectContextual(127);
    if (properties.declare) node.declare = true;
    if ((0, _types.tokenIsIdentifier)(this.state.type)) {
      node.id = this.parseIdentifier();
      this.checkIdentifier(node.id, _scopeflags.BIND_TS_INTERFACE);
    } else {
      node.id = null;
      this.raise(TSErrors.MissingInterfaceName, {
        at: this.state.startLoc
      });
    }
    node.typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutConstModifiers);
    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.checkIdentifier(node.id, _scopeflags.BIND_TS_TYPE);
    node.typeAnnotation = this.tsInType(() => {
      node.typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutModifiers);
      this.expect(29);
      if (this.isContextual(112) && 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;
    }
  }
  tsInDisallowConditionalTypesContext(cb) {
    const oldInDisallowConditionalTypesContext = this.state.inDisallowConditionalTypesContext;
    this.state.inDisallowConditionalTypesContext = true;
    try {
      return cb();
    } finally {
      this.state.inDisallowConditionalTypesContext = oldInDisallowConditionalTypesContext;
    }
  }
  tsInAllowConditionalTypesContext(cb) {
    const oldInDisallowConditionalTypesContext = this.state.inDisallowConditionalTypesContext;
    this.state.inDisallowConditionalTypesContext = false;
    try {
      return cb();
    } finally {
      this.state.inDisallowConditionalTypesContext = oldInDisallowConditionalTypesContext;
    }
  }
  tsEatThenParseType(token) {
    if (this.match(token)) {
      return this.tsNextThenParseType();
    }
  }
  tsExpectThenParseType(token) {
    return this.tsInType(() => {
      this.expect(token);
      return this.tsParseType();
    });
  }
  tsNextThenParseType() {
    return this.tsInType(() => {
      this.next();
      return this.tsParseType();
    });
  }
  tsParseEnumMember() {
    const node = this.startNode();
    node.id = this.match(131) ? super.parseStringLiteral(this.state.value) : this.parseIdentifier(true);
    if (this.eat(29)) {
      node.initializer = super.parseMaybeAssignAllowIn();
    }
    return this.finishNode(node, "TSEnumMember");
  }
  tsParseEnumDeclaration(node, properties = {}) {
    if (properties.const) node.const = true;
    if (properties.declare) node.declare = true;
    this.expectContextual(124);
    node.id = this.parseIdentifier();
    this.checkIdentifier(node.id, node.const ? _scopeflags.BIND_TS_CONST_ENUM : _scopeflags.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(_scopeflags.SCOPE_OTHER);
    this.expect(5);
    super.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.checkIdentifier(node.id, _scopeflags.BIND_TS_NAMESPACE);
    }
    if (this.eat(16)) {
      const inner = this.startNode();
      this.tsParseModuleOrNamespaceDeclaration(inner, true);
      node.body = inner;
    } else {
      this.scope.enter(_scopeflags.SCOPE_TS_MODULE);
      this.prodParam.enter(_productionParameter.PARAM);
      node.body = this.tsParseModuleBlock();
      this.prodParam.exit();
      this.scope.exit();
    }
    return this.finishNode(node, "TSModuleDeclaration");
  }
  tsParseAmbientExternalModuleDeclaration(node) {
    if (this.isContextual(110)) {
      node.global = true;
      node.id = this.parseIdentifier();
    } else if (this.match(131)) {
      node.id = super.parseStringLiteral(this.state.value);
    } else {
      this.unexpected();
    }
    if (this.match(5)) {
      this.scope.enter(_scopeflags.SCOPE_TS_MODULE);
      this.prodParam.enter(_productionParameter.PARAM);
      node.body = this.tsParseModuleBlock();
      this.prodParam.exit();
      this.scope.exit();
    } else {
      this.semicolon();
    }
    return this.finishNode(node, "TSModuleDeclaration");
  }
  tsParseImportEqualsDeclaration(node, maybeDefaultIdentifier, isExport) {
    node.isExport = isExport || false;
    node.id = maybeDefaultIdentifier || this.parseIdentifier();
    this.checkIdentifier(node.id, _scopeflags.BIND_FLAGS_TS_IMPORT);
    this.expect(29);
    const moduleReference = this.tsParseModuleReference();
    if (node.importKind === "type" && moduleReference.type !== "TSExternalModuleReference") {
      this.raise(TSErrors.ImportAliasHasImportType, {
        at: moduleReference
      });
    }
    node.moduleReference = moduleReference;
    this.semicolon();
    return this.finishNode(node, "TSImportEqualsDeclaration");
  }
  tsIsExternalModuleReference() {
    return this.isContextual(117) && this.lookaheadCharCode() === 40;
  }
  tsParseModuleReference() {
    return this.tsIsExternalModuleReference() ? this.tsParseExternalModuleReference() : this.tsParseEntityName(false);
  }
  tsParseExternalModuleReference() {
    const node = this.startNode();
    this.expectContextual(117);
    this.expect(10);
    if (!this.match(131)) {
      this.unexpected();
    }
    node.expression = super.parseExprAtom();
    this.expect(11);
    this.sawUnambiguousESM = true;
    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;
    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;
    }
    this.state = state;
  }
  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 super.parseFunctionStatement(nany, false, false);
        case 80:
          nany.declare = true;
          return this.parseClass(nany, true, false);
        case 124:
          return this.tsParseEnumDeclaration(nany, {
            declare: true
          });
        case 110:
          return this.tsParseAmbientExternalModuleDeclaration(nany);
        case 75:
        case 74:
          if (!this.match(75) || !this.isLookaheadContextual("enum")) {
            nany.declare = true;
            return this.parseVarStatement(nany, kind || this.state.value, true);
          }
          this.expect(75);
          return this.tsParseEnumDeclaration(nany, {
            const: true,
            declare: true
          });
        case 127:
          {
            const result = this.tsParseInterfaceDeclaration(nany, {
              declare: true
            });
            if (result) return result;
          }
        default:
          if ((0, _types.tokenIsIdentifier)(startType)) {
            return this.tsParseDeclaration(nany, this.state.value, true, null);
          }
      }
    });
  }
  tsTryParseExportDeclaration() {
    return this.tsParseDeclaration(this.startNode(), this.state.value, true, null);
  }
  tsParseExpressionStatement(node, expr, decorators) {
    switch (expr.name) {
      case "declare":
        {
          const declaration = this.tsTryParseDeclare(node);
          if (declaration) {
            declaration.declare = true;
          }
          return declaration;
        }
      case "global":
        if (this.match(5)) {
          this.scope.enter(_scopeflags.SCOPE_TS_MODULE);
          this.prodParam.enter(_productionParameter.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, decorators);
    }
  }
  tsParseDeclaration(node, value, next, decorators) {
    switch (value) {
      case "abstract":
        if (this.tsCheckLineTerminator(next) && (this.match(80) || (0, _types.tokenIsIdentifier)(this.state.type))) {
          return this.tsParseAbstractDeclaration(node, decorators);
        }
        break;
      case "module":
        if (this.tsCheckLineTerminator(next)) {
          if (this.match(131)) {
            return this.tsParseAmbientExternalModuleDeclaration(node);
          } else if ((0, _types.tokenIsIdentifier)(this.state.type)) {
            return this.tsParseModuleOrNamespaceDeclaration(node);
          }
        }
        break;
      case "namespace":
        if (this.tsCheckLineTerminator(next) && (0, _types.tokenIsIdentifier)(this.state.type)) {
          return this.tsParseModuleOrNamespaceDeclaration(node);
        }
        break;
      case "type":
        if (this.tsCheckLineTerminator(next) && (0, _types.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(startLoc) {
    if (!this.match(47)) return;
    const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;
    this.state.maybeInArrowParameters = true;
    const res = this.tsTryParseAndCatch(() => {
      const node = this.startNodeAt(startLoc);
      node.typeParameters = this.tsParseTypeParameters(this.tsParseConstModifier);
      super.parseFunctionParams(node);
      node.returnType = this.tsTryParseTypeOrTypePredicateAnnotation();
      this.expect(19);
      return node;
    });
    this.state.maybeInArrowParameters = oldMaybeInArrowParameters;
    if (!res) return;
    return super.parseArrowExpression(res, null, true);
  }
  tsParseTypeArgumentsInExpression() {
    if (this.reScan_lt() !== 47) return;
    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, {
        at: node
      });
    } else if (!this.state.inType && this.curContext() === _context.types.brace) {
      this.reScan_lt_gt();
    }
    this.expect(48);
    return this.finishNode(node, "TSTypeParameterInstantiation");
  }
  tsIsDeclarationStart() {
    return (0, _types.tokenIsTSDeclarationStart)(this.state.type);
  }
  isExportDefaultSpecifier() {
    if (this.tsIsDeclarationStart()) return false;
    return super.isExportDefaultSpecifier();
  }
  parseAssignableListItem(flags, decorators) {
    const startLoc = this.state.startLoc;
    const modified = {};
    this.tsParseModifiers({
      allowedModifiers: ["public", "private", "protected", "override", "readonly"]
    }, modified);
    const accessibility = modified.accessibility;
    const override = modified.override;
    const readonly = modified.readonly;
    if (!(flags & _lval.ParseBindingListFlags.IS_CONSTRUCTOR_PARAMS) && (accessibility || readonly || override)) {
      this.raise(TSErrors.UnexpectedParameterModifier, {
        at: startLoc
      });
    }
    const left = this.parseMaybeDefault();
    this.parseAssignableListItemTypes(left, flags);
    const elt = this.parseMaybeDefault(left.loc.start, left);
    if (accessibility || readonly || override) {
      const pp = this.startNodeAt(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, {
          at: pp
        });
      }
      pp.parameter = elt;
      return this.finishNode(pp, "TSParameterProperty");
    }
    if (decorators.length) {
      left.decorators = decorators;
    }
    return elt;
  }
  isSimpleParameter(node) {
    return node.type === "TSParameterProperty" && super.isSimpleParameter(node.parameter) || super.isSimpleParameter(node);
  }
  tsDisallowOptionalPattern(node) {
    for (const param of node.params) {
      if (param.type !== "Identifier" && param.optional && !this.state.isAmbientContext) {
        this.raise(TSErrors.PatternIsOptional, {
          at: param
        });
      }
    }
  }
  setArrowFunctionParameters(node, params, trailingCommaLoc) {
    super.setArrowFunctionParameters(node, params, trailingCommaLoc);
    this.tsDisallowOptionalPattern(node);
  }
  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()) {
      return this.finishNode(node, bodilessType);
    }
    if (bodilessType === "TSDeclareFunction" && this.state.isAmbientContext) {
      this.raise(TSErrors.DeclareFunctionHasImplementation, {
        at: node
      });
      if (node.declare) {
        return super.parseFunctionBodyAndFinish(node, bodilessType, isMethod);
      }
    }
    this.tsDisallowOptionalPattern(node);
    return super.parseFunctionBodyAndFinish(node, type, isMethod);
  }
  registerFunctionStatementId(node) {
    if (!node.body && node.id) {
      this.checkIdentifier(node.id, _scopeflags.BIND_TS_AMBIENT);
    } else {
      super.registerFunctionStatementId(node);
    }
  }
  tsCheckForInvalidTypeCasts(items) {
    items.forEach(node => {
      if ((node == null ? void 0 : node.type) === "TSTypeCastExpression") {
        this.raise(TSErrors.UnexpectedTypeAnnotation, {
          at: node.typeAnnotation
        });
      }
    });
  }
  toReferencedList(exprList, isInParens) {
    this.tsCheckForInvalidTypeCasts(exprList);
    return exprList;
  }
  parseArrayLike(close, canBePattern, isTuple, refExpressionErrors) {
    const node = super.parseArrayLike(close, canBePattern, isTuple, refExpressionErrors);
    if (node.type === "ArrayExpression") {
      this.tsCheckForInvalidTypeCasts(node.elements);
    }
    return node;
  }
  parseSubscript(base, startLoc, noCalls, state) {
    if (!this.hasPrecedingLineBreak() && this.match(35)) {
      this.state.canStartJSXElement = false;
      this.next();
      const nonNullExpression = this.startNodeAt(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(startLoc);
          if (asyncArrowFn) {
            return asyncArrowFn;
          }
        }
        const typeArguments = this.tsParseTypeArgumentsInExpression();
        if (!typeArguments) return;
        if (isOptionalCall && !this.match(10)) {
          missingParenErrorLoc = this.state.curPosition();
          return;
        }
        if ((0, _types.tokenIsTemplate)(this.state.type)) {
          const result = super.parseTaggedTemplateExpression(base, startLoc, state);
          result.typeParameters = typeArguments;
          return result;
        }
        if (!noCalls && this.eat(10)) {
          const node = this.startNodeAt(startLoc);
          node.callee = base;
          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);
        }
        const tokenType = this.state.type;
        if (tokenType === 48 || tokenType === 52 || tokenType !== 10 && (0, _types.tokenCanStartExpression)(tokenType) && !this.hasPrecedingLineBreak()) {
          return;
        }
        const node = this.startNodeAt(startLoc);
        node.expression = base;
        node.typeParameters = typeArguments;
        return this.finishNode(node, "TSInstantiationExpression");
      });
      if (missingParenErrorLoc) {
        this.unexpected(missingParenErrorLoc, 10);
      }
      if (result) {
        if (result.type === "TSInstantiationExpression" && (this.match(16) || this.match(18) && this.lookaheadCharCode() !== 40)) {
          this.raise(TSErrors.InvalidPropertyAccessAfterInstantiationExpression, {
            at: this.state.startLoc
          });
        }
        return result;
      }
    }
    return super.parseSubscript(base, startLoc, noCalls, state);
  }
  parseNewCallee(node) {
    var _callee$extra;
    super.parseNewCallee(node);
    const {
      callee
    } = node;
    if (callee.type === "TSInstantiationExpression" && !((_callee$extra = callee.extra) != null && _callee$extra.parenthesized)) {
      node.typeParameters = callee.typeParameters;
      node.callee = callee.expression;
    }
  }
  parseExprOp(left, leftStartLoc, minPrec) {
    let isSatisfies;
    if ((0, _types.tokenOperatorPrecedence)(58) > minPrec && !this.hasPrecedingLineBreak() && (this.isContextual(93) || (isSatisfies = this.isContextual(118)))) {
      const node = this.startNodeAt(leftStartLoc);
      node.expression = left;
      node.typeAnnotation = this.tsInType(() => {
        this.next();
        if (this.match(75)) {
          if (isSatisfies) {
            this.raise(_parseError.Errors.UnexpectedKeyword, {
              at: this.state.startLoc,
              keyword: "const"
            });
          }
          return this.tsParseTypeReference();
        }
        return this.tsParseType();
      });
      this.finishNode(node, isSatisfies ? "TSSatisfiesExpression" : "TSAsExpression");
      this.reScan_lt_gt();
      return this.parseExprOp(node, leftStartLoc, minPrec);
    }
    return super.parseExprOp(left, leftStartLoc, minPrec);
  }
  checkReservedWord(word, startLoc, checkKeywords, isBinding) {
    if (!this.state.isAmbientContext) {
      super.checkReservedWord(word, startLoc, checkKeywords, isBinding);
    }
  }
  checkImportReflection(node) {
    super.checkImportReflection(node);
    if (node.module && node.importKind !== "value") {
      this.raise(TSErrors.ImportReflectionHasImportType, {
        at: node.specifiers[0].loc.start
      });
    }
  }
  checkDuplicateExports() {}
  isPotentialImportPhase(isExport) {
    if (super.isPotentialImportPhase(isExport)) return true;
    if (this.isContextual(128)) {
      const ch = this.lookaheadCharCode();
      return isExport ? ch === 123 || ch === 42 : ch !== 61;
    }
    return !isExport && this.isContextual(87);
  }
  applyImportPhase(node, isExport, phase, loc) {
    super.applyImportPhase(node, isExport, phase, loc);
    if (isExport) {
      node.exportKind = phase === "type" ? "type" : "value";
    } else {
      node.importKind = phase === "type" || phase === "typeof" ? phase : "value";
    }
  }
  parseImport(node) {
    if (this.match(131)) {
      node.importKind = "value";
      return super.parseImport(node);
    }
    let importNode;
    if ((0, _types.tokenIsIdentifier)(this.state.type) && this.lookaheadCharCode() === 61) {
      node.importKind = "value";
      return this.tsParseImportEqualsDeclaration(node);
    } else if (this.isContextual(128)) {
      const maybeDefaultIdentifier = this.parseMaybeImportPhase(node, false);
      if (this.lookaheadCharCode() === 61) {
        return this.tsParseImportEqualsDeclaration(node, maybeDefaultIdentifier);
      } else {
        importNode = super.parseImportSpecifiersAndAfter(node, maybeDefaultIdentifier);
      }
    } else {
      importNode = super.parseImport(node);
    }
    if (importNode.importKind === "type" && importNode.specifiers.length > 1 && importNode.specifiers[0].type === "ImportDefaultSpecifier") {
      this.raise(TSErrors.TypeImportCannotSpecifyDefaultAndNamed, {
        at: importNode
      });
    }
    return importNode;
  }
  parseExport(node, decorators) {
    if (this.match(83)) {
      this.next();
      let maybeDefaultIdentifier = null;
      if (this.isContextual(128) && this.isPotentialImportPhase(false)) {
        maybeDefaultIdentifier = this.parseMaybeImportPhase(node, false);
      } else {
        node.importKind = "value";
      }
      return this.tsParseImportEqualsDeclaration(node, maybeDefaultIdentifier, true);
    } else if (this.eat(29)) {
      const assign = node;
      assign.expression = super.parseExpression();
      this.semicolon();
      this.sawUnambiguousESM = true;
      return this.finishNode(assign, "TSExportAssignment");
    } else if (this.eatContextual(93)) {
      const decl = node;
      this.expectContextual(126);
      decl.id = this.parseIdentifier();
      this.semicolon();
      return this.finishNode(decl, "TSNamespaceExportDeclaration");
    } else {
      return super.parseExport(node, decorators);
    }
  }
  isAbstractClass() {
    return this.isContextual(122) && this.lookahead().type === 80;
  }
  parseExportDefaultExpression() {
    if (this.isAbstractClass()) {
      const cls = this.startNode();
      this.next();
      cls.abstract = true;
      return this.parseClass(cls, true, true);
    }
    if (this.match(127)) {
      const result = this.tsParseInterfaceDeclaration(this.startNode());
      if (result) return result;
    }
    return super.parseExportDefaultExpression();
  }
  parseVarStatement(node, kind, allowMissingInitializer = false) {
    const {
      isAmbientContext
    } = this.state;
    const declaration = super.parseVarStatement(node, kind, allowMissingInitializer || isAmbientContext);
    if (!isAmbientContext) return declaration;
    for (const {
      id,
      init
    } of declaration.declarations) {
      if (!init) continue;
      if (kind !== "const" || !!id.typeAnnotation) {
        this.raise(TSErrors.InitializerNotAllowedInAmbientContext, {
          at: init
        });
      } else if (!isValidAmbientConstInitializer(init, this.hasPlugin("estree"))) {
        this.raise(TSErrors.ConstInitiailizerMustBeStringOrNumericLiteralOrLiteralEnumReference, {
          at: init
        });
      }
    }
    return declaration;
  }
  parseStatementContent(flags, decorators) {
    if (this.match(75) && this.isLookaheadContextual("enum")) {
      const node = this.startNode();
      this.expect(75);
      return this.tsParseEnumDeclaration(node, {
        const: true
      });
    }
    if (this.isContextual(124)) {
      return this.tsParseEnumDeclaration(this.startNode());
    }
    if (this.isContextual(127)) {
      const result = this.tsParseInterfaceDeclaration(this.startNode());
      if (result) return result;
    }
    return super.parseStatementContent(flags, decorators);
  }
  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({
      allowedModifiers: modifiers,
      disallowedModifiers: ["in", "out"],
      stopOnStartOfClassStaticBlock: true,
      errorTemplate: TSErrors.InvalidModifierOnTypeParameterPositions
    }, member);
    const callParseClassMemberWithIsStatic = () => {
      if (this.tsIsStartOfStaticBlocks()) {
        this.next();
        this.next();
        if (this.tsHasSomeModifiers(member, modifiers)) {
          this.raise(TSErrors.StaticBlockCannotHaveModifier, {
            at: this.state.curPosition()
          });
        }
        super.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, {
          at: member
        });
      }
      if (member.accessibility) {
        this.raise(TSErrors.IndexSignatureHasAccessibility, {
          at: member,
          modifier: member.accessibility
        });
      }
      if (member.declare) {
        this.raise(TSErrors.IndexSignatureHasDeclare, {
          at: member
        });
      }
      if (member.override) {
        this.raise(TSErrors.IndexSignatureHasOverride, {
          at: member
        });
      }
      return;
    }
    if (!this.state.inAbstractClass && member.abstract) {
      this.raise(TSErrors.NonAbstractClassHasAbstractMethod, {
        at: member
      });
    }
    if (member.override) {
      if (!state.hadSuperClass) {
        this.raise(TSErrors.OverrideNotInSubClass, {
          at: 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, {
        at: methodOrProp
      });
    }
    if (methodOrProp.declare && this.match(10)) {
      this.raise(TSErrors.ClassMethodHasDeclare, {
        at: methodOrProp
      });
    }
  }
  parseExpressionStatement(node, expr, decorators) {
    const decl = expr.type === "Identifier" ? this.tsParseExpressionStatement(node, expr, decorators) : undefined;
    return decl || super.parseExpressionStatement(node, expr, decorators);
  }
  shouldParseExportDeclaration() {
    if (this.tsIsDeclarationStart()) return true;
    return super.shouldParseExportDeclaration();
  }
  parseConditional(expr, startLoc, refExpressionErrors) {
    if (!this.state.maybeInArrowParameters || !this.match(17)) {
      return super.parseConditional(expr, startLoc, refExpressionErrors);
    }
    const result = this.tryParse(() => super.parseConditional(expr, 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, startLoc) {
    node = super.parseParenItem(node, startLoc);
    if (this.eat(17)) {
      node.optional = true;
      this.resetEndLocation(node);
    }
    if (this.match(14)) {
      const typeCastNode = this.startNodeAt(startLoc);
      typeCastNode.expression = node;
      typeCastNode.typeAnnotation = this.tsParseTypeAnnotation();
      return this.finishNode(typeCastNode, "TSTypeCastExpression");
    }
    return node;
  }
  parseExportDeclaration(node) {
    if (!this.state.isAmbientContext && this.isContextual(123)) {
      return this.tsInAmbientContext(() => this.parseExportDeclaration(node));
    }
    const startLoc = this.state.startLoc;
    const isDeclare = this.eatContextual(123);
    if (isDeclare && (this.isContextual(123) || !this.shouldParseExportDeclaration())) {
      throw this.raise(TSErrors.ExpectedAmbientAfterExportDeclare, {
        at: this.state.startLoc
      });
    }
    const isIdentifier = (0, _types.tokenIsIdentifier)(this.state.type);
    const declaration = isIdentifier && this.tsTryParseExportDeclaration() || super.parseExportDeclaration(node);
    if (!declaration) return null;
    if (declaration.type === "TSInterfaceDeclaration" || declaration.type === "TSTypeAliasDeclaration" || isDeclare) {
      node.exportKind = "type";
    }
    if (isDeclare) {
      this.resetStartLocation(declaration, startLoc);
      declaration.declare = true;
    }
    return declaration;
  }
  parseClassId(node, isStatement, optionalId, bindingType) {
    if ((!isStatement || optionalId) && this.isContextual(111)) {
      return;
    }
    super.parseClassId(node, isStatement, optionalId, node.declare ? _scopeflags.BIND_TS_AMBIENT : _scopeflags.BIND_CLASS);
    const typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutConstModifiers);
    if (typeParameters) node.typeParameters = typeParameters;
  }
  parseClassPropertyAnnotation(node) {
    if (!node.optional) {
      if (this.eat(35)) {
        node.definite = true;
      } else if (this.eat(17)) {
        node.optional = true;
      }
    }
    const type = this.tsTryParseTypeAnnotation();
    if (type) node.typeAnnotation = type;
  }
  parseClassProperty(node) {
    this.parseClassPropertyAnnotation(node);
    if (this.state.isAmbientContext && !(node.readonly && !node.typeAnnotation) && 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,
        propertyName: 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, {
        at: node
      });
    }
    if (node.accessibility) {
      this.raise(TSErrors.PrivateElementHasAccessibility, {
        at: node,
        modifier: node.accessibility
      });
    }
    this.parseClassPropertyAnnotation(node);
    return super.parseClassPrivateProperty(node);
  }
  parseClassAccessorProperty(node) {
    this.parseClassPropertyAnnotation(node);
    if (node.optional) {
      this.raise(TSErrors.AccessorCannotBeOptional, {
        at: node
      });
    }
    return super.parseClassAccessorProperty(node);
  }
  pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) {
    const typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier);
    if (typeParameters && isConstructor) {
      this.raise(TSErrors.ConstructorHasTypeParameters, {
        at: typeParameters
      });
    }
    const {
      declare = false,
      kind
    } = method;
    if (declare && (kind === "get" || kind === "set")) {
      this.raise(TSErrors.DeclareAccessor, {
        at: method,
        kind
      });
    }
    if (typeParameters) method.typeParameters = typeParameters;
    super.pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper);
  }
  pushClassPrivateMethod(classBody, method, isGenerator, isAsync) {
    const typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier);
    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(111)) {
      node.implements = this.tsParseHeritageClause("implements");
    }
  }
  parseObjPropValue(prop, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors) {
    const typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier);
    if (typeParameters) prop.typeParameters = typeParameters;
    return super.parseObjPropValue(prop, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors);
  }
  parseFunctionParams(node, isConstructor) {
    const typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier);
    if (typeParameters) node.typeParameters = typeParameters;
    super.parseFunctionParams(node, isConstructor);
  }
  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(refExpressionErrors, afterLeftParse) {
    var _jsx, _jsx2, _typeCast, _jsx3, _typeCast2;
    let state;
    let jsx;
    let typeCast;
    if (this.hasPlugin("jsx") && (this.match(140) || 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 === _context.types.j_oTag || currentContext === _context.types.j_expr) {
        context.pop();
      }
    }
    if (!((_jsx = jsx) != null && _jsx.error) && !this.match(47)) {
      return super.parseMaybeAssign(refExpressionErrors, afterLeftParse);
    }
    if (!state || state === this.state) state = this.state.clone();
    let typeParameters;
    const arrow = this.tryParse(abort => {
      var _expr$extra, _typeParameters;
      typeParameters = this.tsParseTypeParameters(this.tsParseConstModifier);
      const expr = super.parseMaybeAssign(refExpressionErrors, afterLeftParse);
      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(refExpressionErrors, afterLeftParse), 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;
    }
    throw ((_jsx3 = jsx) == null ? void 0 : _jsx3.error) || arrow.error || ((_typeCast2 = typeCast) == null ? void 0 : _typeCast2.error);
  }
  reportReservedArrowTypeParam(node) {
    var _node$extra;
    if (node.params.length === 1 && !node.params[0].constraint && !((_node$extra = node.extra) != null && _node$extra.trailingComma) && this.getPluginOption("typescript", "disallowAmbiguousJSXLike")) {
      this.raise(TSErrors.ReservedArrowTypeParam, {
        at: node
      });
    }
  }
  parseMaybeUnary(refExpressionErrors, sawUnary) {
    if (!this.hasPlugin("jsx") && this.match(47)) {
      return this.tsParseTypeAssertion();
    }
    return super.parseMaybeUnary(refExpressionErrors, sawUnary);
  }
  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, flags) {
    if (!(flags & _lval.ParseBindingListFlags.IS_FUNCTION_PARAMS)) return param;
    if (this.eat(17)) {
      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 "ParenthesizedExpression":
        this.toAssignableParenthesizedExpression(node, isLHS);
        break;
      case "TSAsExpression":
      case "TSSatisfiesExpression":
      case "TSNonNullExpression":
      case "TSTypeAssertion":
        if (isLHS) {
          this.expressionScope.recordArrowParameterBindingError(TSErrors.UnexpectedTypeCastInParameter, {
            at: node
          });
        } else {
          this.raise(TSErrors.UnexpectedTypeCastInParameter, {
            at: node
          });
        }
        this.toAssignable(node.expression, isLHS);
        break;
      case "AssignmentExpression":
        if (!isLHS && node.left.type === "TSTypeCastExpression") {
          node.left = this.typeCastToParameter(node.left);
        }
      default:
        super.toAssignable(node, isLHS);
    }
  }
  toAssignableParenthesizedExpression(node, isLHS) {
    switch (node.expression.type) {
      case "TSAsExpression":
      case "TSSatisfiesExpression":
      case "TSNonNullExpression":
      case "TSTypeAssertion":
      case "ParenthesizedExpression":
        this.toAssignable(node.expression, isLHS);
        break;
      default:
        super.toAssignable(node, isLHS);
    }
  }
  checkToRestConversion(node, allowPattern) {
    switch (node.type) {
      case "TSAsExpression":
      case "TSSatisfiesExpression":
      case "TSTypeAssertion":
      case "TSNonNullExpression":
        this.checkToRestConversion(node.expression, false);
        break;
      default:
        super.checkToRestConversion(node, allowPattern);
    }
  }
  isValidLVal(type, isUnparenthesizedInAssign, binding) {
    return getOwn({
      TSTypeCastExpression: true,
      TSParameterProperty: "parameter",
      TSNonNullExpression: "expression",
      TSAsExpression: (binding !== _scopeflags.BIND_NONE || !isUnparenthesizedInAssign) && ["expression", true],
      TSSatisfiesExpression: (binding !== _scopeflags.BIND_NONE || !isUnparenthesizedInAssign) && ["expression", true],
      TSTypeAssertion: (binding !== _scopeflags.BIND_NONE || !isUnparenthesizedInAssign) && ["expression", true]
    }, type) || super.isValidLVal(type, isUnparenthesizedInAssign, binding);
  }
  parseBindingAtom() {
    if (this.state.type === 78) {
      return this.parseIdentifier(true);
    }
    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;
    }
    return super.checkCommaAfterRest(close);
  }
  isClassMethod() {
    return this.match(47) || super.isClassMethod();
  }
  isClassProperty() {
    return this.match(35) || this.match(14) || super.isClassProperty();
  }
  parseMaybeDefault(startLoc, left) {
    const node = super.parseMaybeDefault(startLoc, left);
    if (node.type === "AssignmentPattern" && node.typeAnnotation && node.right.start < node.typeAnnotation.start) {
      this.raise(TSErrors.TypeAnnotationAfterAssign, {
        at: node.typeAnnotation
      });
    }
    return node;
  }
  getTokenFromCode(code) {
    if (this.state.inType) {
      if (code === 62) {
        this.finishOp(48, 1);
        return;
      }
      if (code === 60) {
        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, trailingCommaLoc, isLHS) {
    for (let i = 0; i < exprList.length; i++) {
      const expr = exprList[i];
      if ((expr == null ? void 0 : expr.type) === "TSTypeCastExpression") {
        exprList[i] = this.typeCastToParameter(expr);
      }
    }
    super.toAssignableList(exprList, trailingCommaLoc, isLHS);
  }
  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, isStatement, optionalId) {
    const oldInAbstractClass = this.state.inAbstractClass;
    this.state.inAbstractClass = !!node.abstract;
    try {
      return super.parseClass(node, isStatement, optionalId);
    } finally {
      this.state.inAbstractClass = oldInAbstractClass;
    }
  }
  tsParseAbstractDeclaration(node, decorators) {
    if (this.match(80)) {
      node.abstract = true;
      return this.maybeTakeDecorators(decorators, this.parseClass(node, true, false));
    } else if (this.isContextual(127)) {
      if (!this.hasFollowingLineBreak()) {
        node.abstract = true;
        this.raise(TSErrors.NonClassMethodPropertyHasAbstractModifer, {
          at: node
        });
        return this.tsParseInterfaceDeclaration(node);
      }
    } else {
      this.unexpected(null, 80);
    }
  }
  parseMethod(node, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope) {
    const method = super.parseMethod(node, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope);
    if (method.abstract) {
      const hasBody = this.hasPlugin("estree") ? !!method.value.body : !!method.body;
      if (hasBody) {
        const {
          key
        } = method;
        this.raise(TSErrors.AbstractMethodHasImplementation, {
          at: method,
          methodName: 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, bindingType) {
    if (!importedIsString && isMaybeTypeOnly) {
      this.parseTypeOnlyImportExportSpecifier(specifier, true, isInTypeOnlyImport);
      return this.finishNode(specifier, "ImportSpecifier");
    }
    specifier.importKind = "value";
    return super.parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, isInTypeOnlyImport ? _scopeflags.BIND_TS_TYPE_IMPORT : _scopeflags.BIND_FLAGS_TS_IMPORT);
  }
  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 ((0, _types.tokenIsKeywordOrIdentifier)(this.state.type)) {
          hasTypeSpecifier = true;
          leftOfAs = firstAs;
          rightOfAs = isImport ? this.parseIdentifier() : this.parseModuleExportName();
          canParseAsKeyword = false;
        } else {
          rightOfAs = secondAs;
          canParseAsKeyword = false;
        }
      } else if ((0, _types.tokenIsKeywordOrIdentifier)(this.state.type)) {
        canParseAsKeyword = false;
        rightOfAs = isImport ? this.parseIdentifier() : this.parseModuleExportName();
      } else {
        hasTypeSpecifier = true;
        leftOfAs = firstAs;
      }
    } else if ((0, _types.tokenIsKeywordOrIdentifier)(this.state.type)) {
      hasTypeSpecifier = true;
      if (isImport) {
        leftOfAs = this.parseIdentifier(true);
        if (!this.isContextual(93)) {
          this.checkReservedWord(leftOfAs.name, leftOfAs.loc.start, true, true);
        }
      } else {
        leftOfAs = this.parseModuleExportName();
      }
    }
    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] = (0, _node.cloneIdentifier)(node[leftOfAsKey]);
    }
    if (isImport) {
      this.checkIdentifier(node[rightOfAsKey], hasTypeSpecifier ? _scopeflags.BIND_TS_TYPE_IMPORT : _scopeflags.BIND_FLAGS_TS_IMPORT);
    }
  }
};
exports.default = _default;
function isPossiblyLiteralEnum(expression) {
  if (expression.type !== "MemberExpression") return false;
  const {
    computed,
    property
  } = expression;
  if (computed && property.type !== "StringLiteral" && (property.type !== "TemplateLiteral" || property.expressions.length > 0)) {
    return false;
  }
  return isUncomputedMemberExpressionChain(expression.object);
}
function isValidAmbientConstInitializer(expression, estree) {
  var _expression$extra;
  const {
    type
  } = expression;
  if ((_expression$extra = expression.extra) != null && _expression$extra.parenthesized) {
    return false;
  }
  if (estree) {
    if (type === "Literal") {
      const {
        value
      } = expression;
      if (typeof value === "string" || typeof value === "boolean") {
        return true;
      }
    }
  } else {
    if (type === "StringLiteral" || type === "BooleanLiteral") {
      return true;
    }
  }
  if (isNumber(expression, estree) || isNegativeNumber(expression, estree)) {
    return true;
  }
  if (type === "TemplateLiteral" && expression.expressions.length === 0) {
    return true;
  }
  if (isPossiblyLiteralEnum(expression)) {
    return true;
  }
  return false;
}
function isNumber(expression, estree) {
  if (estree) {
    return expression.type === "Literal" && (typeof expression.value === "number" || "bigint" in expression);
  }
  return expression.type === "NumericLiteral" || expression.type === "BigIntLiteral";
}
function isNegativeNumber(expression, estree) {
  if (expression.type === "UnaryExpression") {
    const {
      operator,
      argument
    } = expression;
    if (operator === "-" && isNumber(argument, estree)) {
      return true;
    }
  }
  return false;
}
function isUncomputedMemberExpressionChain(expression) {
  if (expression.type === "Identifier") return true;
  if (expression.type !== "MemberExpression" || expression.computed) {
    return false;
  }
  return isUncomputedMemberExpressionChain(expression.object);
}

//# sourceMappingURL=index.js.map
�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������lib/plugins/typescript/index.js.map�����������������������������������������������������������������0000644�����������������00000747066�15120211212�0013431 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������{"version":3,"names":["_types","require","_context","_location","_scopeflags","_scope","_productionParameter","_parseError","_node","_lval","getOwn","object","key","Object","hasOwnProperty","call","nonNull","x","Error","assert","TSErrors","ParseErrorEnum","AbstractMethodHasImplementation","methodName","AbstractPropertyHasInitializer","propertyName","AccesorCannotDeclareThisParameter","AccesorCannotHaveTypeParameters","AccessorCannotBeOptional","ClassMethodHasDeclare","ClassMethodHasReadonly","ConstInitiailizerMustBeStringOrNumericLiteralOrLiteralEnumReference","ConstructorHasTypeParameters","DeclareAccessor","kind","DeclareClassFieldHasInitializer","DeclareFunctionHasImplementation","DuplicateAccessibilityModifier","modifier","DuplicateModifier","EmptyHeritageClauseType","token","EmptyTypeArguments","EmptyTypeParameters","ExpectedAmbientAfterExportDeclare","ImportAliasHasImportType","ImportReflectionHasImportType","IncompatibleModifiers","modifiers","IndexSignatureHasAbstract","IndexSignatureHasAccessibility","IndexSignatureHasDeclare","IndexSignatureHasOverride","IndexSignatureHasStatic","InitializerNotAllowedInAmbientContext","InvalidModifierOnTypeMember","InvalidModifierOnTypeParameter","InvalidModifierOnTypeParameterPositions","InvalidModifiersOrder","orderedModifiers","InvalidPropertyAccessAfterInstantiationExpression","InvalidTupleMemberLabel","MissingInterfaceName","MixedLabeledAndUnlabeledElements","NonAbstractClassHasAbstractMethod","NonClassMethodPropertyHasAbstractModifer","OptionalTypeBeforeRequired","OverrideNotInSubClass","PatternIsOptional","PrivateElementHasAbstract","PrivateElementHasAccessibility","ReadonlyForMethodSignature","ReservedArrowTypeParam","ReservedTypeAssertion","SetAccesorCannotHaveOptionalParameter","SetAccesorCannotHaveRestParameter","SetAccesorCannotHaveReturnType","SingleTypeParameterWithoutTrailingComma","typeParameterName","StaticBlockCannotHaveModifier","TupleOptionalAfterType","TypeAnnotationAfterAssign","TypeImportCannotSpecifyDefaultAndNamed","TypeModifierIsUsedInTypeExports","TypeModifierIsUsedInTypeImports","UnexpectedParameterModifier","UnexpectedReadonly","UnexpectedTypeAnnotation","UnexpectedTypeCastInParameter","UnsupportedImportTypeArgument","UnsupportedParameterPropertyKind","UnsupportedSignatureParameterKind","type","keywordTypeFromName","value","undefined","tsIsAccessModifier","tsIsVarianceAnnotations","_default","superClass","TypeScriptParserMixin","constructor","args","tsParseInOutModifiers","tsParseModifiers","bind","allowedModifiers","disallowedModifiers","errorTemplate","tsParseConstModifier","tsParseInOutConstModifiers","getScopeHandler","TypeScriptScopeHandler","tsIsIdentifier","tokenIsIdentifier","state","tsTokenCanFollowModifier","match","isLiteralPropertyName","hasPrecedingLineBreak","tsNextTokenCanFollowModifier","next","tsParseModifier","stopOnStartOfClassStaticBlock","indexOf","tsIsStartOfStaticBlocks","tsTryParse","modified","enforceOrder","loc","before","after","raise","at","incompatible","mod1","mod2","startLoc","concat","accessibility","includes","tsIsListTerminator","tsParseList","parseElement","result","push","tsParseDelimitedList","refTrailingCommaPos","tsParseDelimitedListWorker","expectSuccess","trailingCommaPos","element","eat","lastTokStart","expect","tsParseBracketedList","bracket","skipFirstToken","tsParseImportType","node","startNode","argument","parseExprAtom","qualifier","tsParseEntityName","typeParameters","tsParseTypeArguments","finishNode","allowReservedWords","entity","parseIdentifier","startNodeAtNode","left","right","tsParseTypeReference","typeName","tsParseThisTypePredicate","lhs","parameterName","typeAnnotation","tsParseTypeAnnotation","asserts","tsParseThisTypeNode","tsParseTypeQuery","exprName","tsParseTypeParameter","parseModifiers","name","tsParseTypeParameterName","constraint","tsEatThenParseType","default","tsTryParseTypeParameters","tsParseTypeParameters","unexpected","params","length","addExtra","tsFillSignature","returnToken","signature","returnTokenRequired","paramsKey","returnTypeKey","tsParseBindingListForSignature","tsParseTypeOrTypePredicateAnnotation","list","parseBindingList","ParseBindingListFlags","IS_FUNCTION_PARAMS","pattern","tsParseTypeMemberSemicolon","isLineTerminator","tsParseSignatureMember","tsIsUnambiguouslyIndexSignature","tsTryParseIndexSignature","tsLookAhead","id","resetEndLocation","parameters","tsTryParseTypeAnnotation","tsParsePropertyOrMethodSignature","readonly","optional","nodeAny","method","curPosition","Errors","BadGetterArity","isThisParam","BadSetterArity","firstParameter","property","tsParseTypeMember","createIdentifier","idx","parsePropertyName","computed","tsParseTypeLiteral","members","tsParseObjectTypeMembers","tsIsStartOfMappedType","isContextual","tsParseMappedTypeParameter","tsExpectThenParseType","tsParseMappedType","expectContextual","eatContextual","typeParameter","nameType","tsParseType","tsTryParseType","semicolon","tsParseTupleType","elementTypes","tsParseTupleElementType","seenOptionalElement","labeledElements","forEach","elementNode","_labeledElements","checkType","isLabeled","rest","labeled","label","isWord","tokenIsKeywordOrIdentifier","chAfterWord","lookaheadCharCode","wordName","typeOrLabel","tsParseNonArrayType","startNodeAt","labeledNode","elementType","lastTokStartLoc","optionalTypeNode","restNode","tsParseParenthesizedType","tsParseFunctionOrConstructorType","abstract","tsInAllowConditionalTypesContext","tsParseLiteralTypeNode","literal","tsParseTemplateLiteralType","parseTemplate","parseTemplateSubstitution","inType","tsParseThisTypeOrThisTypePredicate","thisKeyword","nextToken","lookahead","parseMaybeUnary","nodeType","tsParseArrayTypeOrHigher","objectType","indexType","tsParseTypeOperator","operator","tsParseTypeOperatorOrHigher","tsCheckTypeAnnotationForReadOnly","tsParseInferType","tsParseConstraintForInferType","tsInDisallowConditionalTypesContext","inDisallowConditionalTypesContext","isTypeOperator","tokenIsTSTypeOperator","containsEsc","tsParseUnionOrIntersectionType","parseConstituentType","hasLeadingOperator","types","tsParseIntersectionTypeOrHigher","tsParseUnionTypeOrHigher","tsIsStartOfFunctionType","tsIsUnambiguouslyStartOfFunctionType","tsSkipParameterStart","errors","previousErrorCount","parseObjectLike","_unused","ALLOW_EMPTY","_unused2","tsInType","t","tsParseTypePredicateAsserts","thisTypePredicate","resetStartLocationFromNode","typePredicateVariable","tsParseTypePredicatePrefix","tsTryParseTypeOrTypePredicateAnnotation","InvalidEscapedReservedWord","reservedWord","eatColon","tsParseNonConditionalType","extendsType","trueType","falseType","isAbstractConstructorSignature","tsParseTypeAssertion","getPluginOption","expression","tsParseHeritageClause","originalStartLoc","delimitedList","tsParseInterfaceDeclaration","properties","hasFollowingLineBreak","declare","checkIdentifier","BIND_TS_INTERFACE","extends","body","tsParseTypeAliasDeclaration","BIND_TS_TYPE","tsInNoContext","cb","oldContext","context","oldInType","oldInDisallowConditionalTypesContext","tsNextThenParseType","tsParseEnumMember","parseStringLiteral","initializer","parseMaybeAssignAllowIn","tsParseEnumDeclaration","const","BIND_TS_CONST_ENUM","BIND_TS_ENUM","tsParseModuleBlock","scope","enter","SCOPE_OTHER","parseBlockOrModuleBlockBody","exit","tsParseModuleOrNamespaceDeclaration","nested","BIND_TS_NAMESPACE","inner","SCOPE_TS_MODULE","prodParam","PARAM","tsParseAmbientExternalModuleDeclaration","global","tsParseImportEqualsDeclaration","maybeDefaultIdentifier","isExport","BIND_FLAGS_TS_IMPORT","moduleReference","tsParseModuleReference","importKind","tsIsExternalModuleReference","tsParseExternalModuleReference","sawUnambiguousESM","f","clone","res","tsTryParseAndCatch","tryParse","abort","aborted","error","failState","tsTryParseDeclare","nany","startType","tsInAmbientContext","parseFunctionStatement","parseClass","isLookaheadContextual","parseVarStatement","tsParseDeclaration","tsTryParseExportDeclaration","tsParseExpressionStatement","expr","decorators","declaration","mod","tsCheckLineTerminator","tsParseAbstractDeclaration","tsTryParseGenericAsyncArrowFunction","oldMaybeInArrowParameters","maybeInArrowParameters","parseFunctionParams","returnType","parseArrowExpression","tsParseTypeArgumentsInExpression","reScan_lt","curContext","tc","brace","reScan_lt_gt","tsIsDeclarationStart","tokenIsTSDeclarationStart","isExportDefaultSpecifier","parseAssignableListItem","flags","override","IS_CONSTRUCTOR_PARAMS","parseMaybeDefault","parseAssignableListItemTypes","elt","start","pp","parameter","isSimpleParameter","tsDisallowOptionalPattern","param","isAmbientContext","setArrowFunctionParameters","trailingCommaLoc","parseFunctionBodyAndFinish","isMethod","bodilessType","registerFunctionStatementId","BIND_TS_AMBIENT","tsCheckForInvalidTypeCasts","items","toReferencedList","exprList","isInParens","parseArrayLike","close","canBePattern","isTuple","refExpressionErrors","elements","parseSubscript","base","noCalls","canStartJSXElement","nonNullExpression","isOptionalCall","stop","optionalChainMember","missingParenErrorLoc","atPossibleAsyncArrow","asyncArrowFn","typeArguments","tokenIsTemplate","parseTaggedTemplateExpression","callee","arguments","parseCallExpressionArguments","finishCallExpression","tokenType","tokenCanStartExpression","parseNewCallee","_callee$extra","extra","parenthesized","parseExprOp","leftStartLoc","minPrec","isSatisfies","tokenOperatorPrecedence","UnexpectedKeyword","keyword","checkReservedWord","word","checkKeywords","isBinding","checkImportReflection","module","specifiers","checkDuplicateExports","isPotentialImportPhase","ch","applyImportPhase","phase","exportKind","parseImport","importNode","parseMaybeImportPhase","parseImportSpecifiersAndAfter","parseExport","assign","parseExpression","decl","isAbstractClass","parseExportDefaultExpression","cls","allowMissingInitializer","init","declarations","isValidAmbientConstInitializer","hasPlugin","parseStatementContent","parseAccessModifier","tsHasSomeModifiers","member","some","parseClassMember","classBody","callParseClassMemberWithIsStatic","parseClassStaticBlock","parseClassMemberWithIsStatic","static","isStatic","inAbstractClass","hadSuperClass","parsePostMemberNameModifiers","methodOrProp","parseExpressionStatement","shouldParseExportDeclaration","parseConditional","setOptionalParametersError","parseParenItem","typeCastNode","parseExportDeclaration","isDeclare","isIdentifier","resetStartLocation","parseClassId","isStatement","optionalId","bindingType","BIND_CLASS","parseClassPropertyAnnotation","definite","parseClassProperty","input","slice","end","parseClassPrivateProperty","parseClassAccessorProperty","pushClassMethod","isGenerator","isAsync","isConstructor","allowsDirectSuper","pushClassPrivateMethod","declareClassPrivateMethodInScope","parseClassSuper","superTypeParameters","implements","parseObjPropValue","prop","isPattern","isAccessor","parseVarId","parseAsyncArrowFromCallExpression","parseMaybeAssign","afterLeftParse","_jsx","_jsx2","_typeCast","_jsx3","_typeCast2","jsx","typeCast","currentContext","j_oTag","j_expr","pop","arrow","_expr$extra","_typeParameters","reportReservedArrowTypeParam","_node$extra","trailingComma","sawUnary","parseArrow","canInsertSemicolon","thrown","isAssignable","toAssignable","isLHS","toAssignableParenthesizedExpression","expressionScope","recordArrowParameterBindingError","typeCastToParameter","checkToRestConversion","allowPattern","isValidLVal","isUnparenthesizedInAssign","binding","TSTypeCastExpression","TSParameterProperty","TSNonNullExpression","TSAsExpression","BIND_NONE","TSSatisfiesExpression","TSTypeAssertion","parseBindingAtom","parseMaybeDecoratorArguments","checkCommaAfterRest","isClassMethod","isClassProperty","getTokenFromCode","code","finishOp","pos","readToken_lt","readToken_gt","toAssignableList","i","shouldParseArrow","every","shouldParseAsyncArrow","canHaveLeadingDecorator","jsxParseOpeningElementAfterName","getGetterSetterExpectedParamCount","baseCount","getObjectOrClassMethodParams","firstParam","hasContextParam","parseCatchClauseParam","oldIsAmbientContext","oldInAbstractClass","maybeTakeDecorators","parseMethod","allowDirectSuper","inClassScope","hasBody","shouldParseAsAmbientContext","parse","getExpression","parseExportSpecifier","isString","isInTypeExport","isMaybeTypeOnly","parseTypeOnlyImportExportSpecifier","parseImportSpecifier","specifier","importedIsString","isInTypeOnlyImport","BIND_TS_TYPE_IMPORT","isImport","isInTypeOnlyImportExport","leftOfAsKey","rightOfAsKey","leftOfAs","rightOfAs","hasTypeSpecifier","canParseAsKeyword","firstAs","secondAs","parseModuleExportName","kindKey","cloneIdentifier","exports","isPossiblyLiteralEnum","expressions","isUncomputedMemberExpressionChain","estree","_expression$extra","isNumber","isNegativeNumber"],"sources":["../../../src/plugins/typescript/index.ts"],"sourcesContent":["/*:: declare var invariant; */\n\nimport type State from \"../../tokenizer/state\";\nimport {\n  tokenIsIdentifier,\n  tokenIsTSDeclarationStart,\n  tokenIsTSTypeOperator,\n  tokenOperatorPrecedence,\n  tokenIsKeywordOrIdentifier,\n  tt,\n  type TokenType,\n  tokenIsTemplate,\n  tokenCanStartExpression,\n} from \"../../tokenizer/types\";\nimport { types as tc } from \"../../tokenizer/context\";\nimport type * as N from \"../../types\";\nimport type { Position } from \"../../util/location\";\nimport { createPositionWithColumnOffset } from \"../../util/location\";\nimport type Parser from \"../../parser\";\nimport {\n  type BindingTypes,\n  SCOPE_TS_MODULE,\n  SCOPE_OTHER,\n  BIND_TS_ENUM,\n  BIND_TS_CONST_ENUM,\n  BIND_TS_TYPE,\n  BIND_TS_INTERFACE,\n  BIND_TS_AMBIENT,\n  BIND_TS_NAMESPACE,\n  BIND_TS_TYPE_IMPORT,\n  BIND_CLASS,\n  BIND_NONE,\n  BIND_FLAGS_TS_IMPORT,\n} from \"../../util/scopeflags\";\nimport TypeScriptScopeHandler from \"./scope\";\nimport * as charCodes from \"charcodes\";\nimport type { ExpressionErrors } from \"../../parser/util\";\nimport type { ParseStatementFlag } from \"../../parser/statement\";\nimport { PARAM } from \"../../util/production-parameter\";\nimport { Errors, ParseErrorEnum } from \"../../parse-error\";\nimport { cloneIdentifier, type Undone } from \"../../parser/node\";\nimport type { Pattern } from \"../../types\";\nimport type { Expression } from \"../../types\";\nimport type { IJSXParserMixin } from \"../jsx\";\nimport { ParseBindingListFlags } from \"../../parser/lval\";\n\nconst getOwn = <T extends {}>(object: T, key: keyof T) =>\n  Object.hasOwnProperty.call(object, key) && object[key];\n\ntype TsModifier =\n  | \"readonly\"\n  | \"abstract\"\n  | \"declare\"\n  | \"static\"\n  | \"override\"\n  | \"const\"\n  | N.Accessibility\n  | N.VarianceAnnotations;\n\nfunction nonNull<T>(x?: T | null): T {\n  if (x == null) {\n    throw new Error(`Unexpected ${x} value.`);\n  }\n  return x;\n}\n\nfunction assert(x: boolean): void {\n  if (!x) {\n    throw new Error(\"Assert fail\");\n  }\n}\n\ntype ParsingContext =\n  | \"EnumMembers\"\n  | \"HeritageClauseElement\"\n  | \"TupleElementTypes\"\n  | \"TypeMembers\"\n  | \"TypeParametersOrArguments\";\n\ntype ModifierBase = {\n  accessibility?: N.Accessibility;\n} & {\n  [key in TsModifier]?: boolean | undefined | null;\n};\n\n/* eslint sort-keys: \"error\" */\nconst TSErrors = ParseErrorEnum`typescript`({\n  AbstractMethodHasImplementation: ({ methodName }: { methodName: string }) =>\n    `Method '${methodName}' cannot have an implementation because it is marked abstract.`,\n  AbstractPropertyHasInitializer: ({\n    propertyName,\n  }: {\n    propertyName: string;\n  }) =>\n    `Property '${propertyName}' cannot have an initializer because it is marked abstract.`,\n  AccesorCannotDeclareThisParameter:\n    \"'get' and 'set' accessors cannot declare 'this' parameters.\",\n  AccesorCannotHaveTypeParameters: \"An accessor cannot have type parameters.\",\n  AccessorCannotBeOptional:\n    \"An 'accessor' property cannot be declared optional.\",\n  ClassMethodHasDeclare: \"Class methods cannot have the 'declare' modifier.\",\n  ClassMethodHasReadonly: \"Class methods cannot have the 'readonly' modifier.\",\n  ConstInitiailizerMustBeStringOrNumericLiteralOrLiteralEnumReference:\n    \"A 'const' initializer in an ambient context must be a string or numeric literal or literal enum reference.\",\n  ConstructorHasTypeParameters:\n    \"Type parameters cannot appear on a constructor declaration.\",\n  DeclareAccessor: ({ kind }: { kind: \"get\" | \"set\" }) =>\n    `'declare' is not allowed in ${kind}ters.`,\n  DeclareClassFieldHasInitializer:\n    \"Initializers are not allowed in ambient contexts.\",\n  DeclareFunctionHasImplementation:\n    \"An implementation cannot be declared in ambient contexts.\",\n  DuplicateAccessibilityModifier:\n    // `Accessibility modifier already seen: ${modifier}` would be more helpful.\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    ({ modifier }: { modifier: N.Accessibility }) =>\n      `Accessibility modifier already seen.`,\n  DuplicateModifier: ({ modifier }: { modifier: TsModifier }) =>\n    `Duplicate modifier: '${modifier}'.`,\n  // `token` matches the terminology used by typescript:\n  // https://github.com/microsoft/TypeScript/blob/main/src/compiler/types.ts#L2915\n  EmptyHeritageClauseType: ({ token }: { token: \"extends\" | \"implements\" }) =>\n    `'${token}' list cannot be empty.`,\n  EmptyTypeArguments: \"Type argument list cannot be empty.\",\n  EmptyTypeParameters: \"Type parameter list cannot be empty.\",\n  ExpectedAmbientAfterExportDeclare:\n    \"'export declare' must be followed by an ambient declaration.\",\n  ImportAliasHasImportType: \"An import alias can not use 'import type'.\",\n  ImportReflectionHasImportType:\n    \"An `import module` declaration can not use `type` modifier\",\n  IncompatibleModifiers: ({\n    modifiers,\n  }: {\n    modifiers: [TsModifier, TsModifier];\n  }) =>\n    `'${modifiers[0]}' modifier cannot be used with '${modifiers[1]}' modifier.`,\n  IndexSignatureHasAbstract:\n    \"Index signatures cannot have the 'abstract' modifier.\",\n  IndexSignatureHasAccessibility: ({\n    modifier,\n  }: {\n    modifier: N.Accessibility;\n  }) =>\n    `Index signatures cannot have an accessibility modifier ('${modifier}').`,\n  IndexSignatureHasDeclare:\n    \"Index signatures cannot have the 'declare' modifier.\",\n  IndexSignatureHasOverride:\n    \"'override' modifier cannot appear on an index signature.\",\n  IndexSignatureHasStatic:\n    \"Index signatures cannot have the 'static' modifier.\",\n  InitializerNotAllowedInAmbientContext:\n    \"Initializers are not allowed in ambient contexts.\",\n  InvalidModifierOnTypeMember: ({ modifier }: { modifier: TsModifier }) =>\n    `'${modifier}' modifier cannot appear on a type member.`,\n  InvalidModifierOnTypeParameter: ({ modifier }: { modifier: TsModifier }) =>\n    `'${modifier}' modifier cannot appear on a type parameter.`,\n  InvalidModifierOnTypeParameterPositions: ({\n    modifier,\n  }: {\n    modifier: TsModifier;\n  }) =>\n    `'${modifier}' modifier can only appear on a type parameter of a class, interface or type alias.`,\n  InvalidModifiersOrder: ({\n    orderedModifiers,\n  }: {\n    orderedModifiers: [TsModifier, TsModifier];\n  }) =>\n    `'${orderedModifiers[0]}' modifier must precede '${orderedModifiers[1]}' modifier.`,\n  InvalidPropertyAccessAfterInstantiationExpression:\n    \"Invalid property access after an instantiation expression. \" +\n    \"You can either wrap the instantiation expression in parentheses, or delete the type arguments.\",\n  InvalidTupleMemberLabel:\n    \"Tuple members must be labeled with a simple identifier.\",\n  MissingInterfaceName:\n    \"'interface' declarations must be followed by an identifier.\",\n  MixedLabeledAndUnlabeledElements:\n    \"Tuple members must all have names or all not have names.\",\n  NonAbstractClassHasAbstractMethod:\n    \"Abstract methods can only appear within an abstract class.\",\n  NonClassMethodPropertyHasAbstractModifer:\n    \"'abstract' modifier can only appear on a class, method, or property declaration.\",\n  OptionalTypeBeforeRequired:\n    \"A required element cannot follow an optional element.\",\n  OverrideNotInSubClass:\n    \"This member cannot have an 'override' modifier because its containing class does not extend another class.\",\n  PatternIsOptional:\n    \"A binding pattern parameter cannot be optional in an implementation signature.\",\n  PrivateElementHasAbstract:\n    \"Private elements cannot have the 'abstract' modifier.\",\n  PrivateElementHasAccessibility: ({\n    modifier,\n  }: {\n    modifier: N.Accessibility;\n  }) =>\n    `Private elements cannot have an accessibility modifier ('${modifier}').`,\n  ReadonlyForMethodSignature:\n    \"'readonly' modifier can only appear on a property declaration or index signature.\",\n  ReservedArrowTypeParam:\n    \"This syntax is reserved in files with the .mts or .cts extension. Add a trailing comma, as in `<T,>() => ...`.\",\n  ReservedTypeAssertion:\n    \"This syntax is reserved in files with the .mts or .cts extension. Use an `as` expression instead.\",\n  // TODO: Accesor -> Accessor\n  SetAccesorCannotHaveOptionalParameter:\n    \"A 'set' accessor cannot have an optional parameter.\",\n  SetAccesorCannotHaveRestParameter:\n    \"A 'set' accessor cannot have rest parameter.\",\n  SetAccesorCannotHaveReturnType:\n    \"A 'set' accessor cannot have a return type annotation.\",\n  SingleTypeParameterWithoutTrailingComma: ({\n    typeParameterName,\n  }: {\n    typeParameterName: string;\n  }) =>\n    `Single type parameter ${typeParameterName} should have a trailing comma. Example usage: <${typeParameterName},>.`,\n  StaticBlockCannotHaveModifier:\n    \"Static class blocks cannot have any modifier.\",\n  TupleOptionalAfterType:\n    \"A labeled tuple optional element must be declared using a question mark after the name and before the colon (`name?: type`), rather than after the type (`name: type?`).\",\n  TypeAnnotationAfterAssign:\n    \"Type annotations must come before default assignments, e.g. instead of `age = 25: number` use `age: number = 25`.\",\n  TypeImportCannotSpecifyDefaultAndNamed:\n    \"A type-only import can specify a default import or named bindings, but not both.\",\n  TypeModifierIsUsedInTypeExports:\n    \"The 'type' modifier cannot be used on a named export when 'export type' is used on its export statement.\",\n  TypeModifierIsUsedInTypeImports:\n    \"The 'type' modifier cannot be used on a named import when 'import type' is used on its import statement.\",\n  UnexpectedParameterModifier:\n    \"A parameter property is only allowed in a constructor implementation.\",\n  UnexpectedReadonly:\n    \"'readonly' type modifier is only permitted on array and tuple literal types.\",\n  UnexpectedTypeAnnotation: \"Did not expect a type annotation here.\",\n  UnexpectedTypeCastInParameter: \"Unexpected type cast in parameter position.\",\n  UnsupportedImportTypeArgument:\n    \"Argument in a type import must be a string literal.\",\n  UnsupportedParameterPropertyKind:\n    \"A parameter property may not be declared using a binding pattern.\",\n  UnsupportedSignatureParameterKind: ({ type }: { type: string }) =>\n    `Name in a signature must be an Identifier, ObjectPattern or ArrayPattern, instead got ${type}.`,\n});\n\n/* eslint-disable sort-keys */\n\n// Doesn't handle \"void\" or \"null\" because those are keywords, not identifiers.\n// It also doesn't handle \"intrinsic\", since usually it's not a keyword.\nfunction keywordTypeFromName(value: string): N.TsKeywordTypeType | undefined {\n  switch (value) {\n    case \"any\":\n      return \"TSAnyKeyword\";\n    case \"boolean\":\n      return \"TSBooleanKeyword\";\n    case \"bigint\":\n      return \"TSBigIntKeyword\";\n    case \"never\":\n      return \"TSNeverKeyword\";\n    case \"number\":\n      return \"TSNumberKeyword\";\n    case \"object\":\n      return \"TSObjectKeyword\";\n    case \"string\":\n      return \"TSStringKeyword\";\n    case \"symbol\":\n      return \"TSSymbolKeyword\";\n    case \"undefined\":\n      return \"TSUndefinedKeyword\";\n    case \"unknown\":\n      return \"TSUnknownKeyword\";\n    default:\n      return undefined;\n  }\n}\n\nfunction tsIsAccessModifier(modifier: string): modifier is N.Accessibility {\n  return (\n    modifier === \"private\" || modifier === \"public\" || modifier === \"protected\"\n  );\n}\n\nfunction tsIsVarianceAnnotations(\n  modifier: string,\n): modifier is N.VarianceAnnotations {\n  return modifier === \"in\" || modifier === \"out\";\n}\n\ntype ClassWithMixin<\n  T extends new (...args: any) => any,\n  M extends object,\n> = T extends new (...args: infer P) => infer I\n  ? new (...args: P) => I & M\n  : never;\n\nexport default (superClass: ClassWithMixin<typeof Parser, IJSXParserMixin>) =>\n  class TypeScriptParserMixin extends superClass implements Parser {\n    getScopeHandler(): {\n      new (...args: any): TypeScriptScopeHandler;\n    } {\n      return TypeScriptScopeHandler;\n    }\n\n    tsIsIdentifier(): boolean {\n      // TODO: actually a bit more complex in TypeScript, but shouldn't matter.\n      // See https://github.com/Microsoft/TypeScript/issues/15008\n      return tokenIsIdentifier(this.state.type);\n    }\n\n    tsTokenCanFollowModifier() {\n      return (\n        (this.match(tt.bracketL) ||\n          this.match(tt.braceL) ||\n          this.match(tt.star) ||\n          this.match(tt.ellipsis) ||\n          this.match(tt.privateName) ||\n          this.isLiteralPropertyName()) &&\n        !this.hasPrecedingLineBreak()\n      );\n    }\n\n    tsNextTokenCanFollowModifier() {\n      // Note: TypeScript's implementation is much more complicated because\n      // more things are considered modifiers there.\n      // This implementation only handles modifiers not handled by @babel/parser itself. And \"static\".\n      // TODO: Would be nice to avoid lookahead. Want a hasLineBreakUpNext() method...\n      this.next();\n      return this.tsTokenCanFollowModifier();\n    }\n\n    /** Parses a modifier matching one the given modifier names. */\n    tsParseModifier<T extends TsModifier>(\n      allowedModifiers: T[],\n      stopOnStartOfClassStaticBlock?: boolean,\n    ): T | undefined | null {\n      if (\n        !tokenIsIdentifier(this.state.type) &&\n        this.state.type !== tt._in &&\n        this.state.type !== tt._const\n      ) {\n        return undefined;\n      }\n\n      const modifier = this.state.value;\n      if (allowedModifiers.indexOf(modifier) !== -1) {\n        if (stopOnStartOfClassStaticBlock && this.tsIsStartOfStaticBlocks()) {\n          return undefined;\n        }\n        if (this.tsTryParse(this.tsNextTokenCanFollowModifier.bind(this))) {\n          return modifier;\n        }\n      }\n      return undefined;\n    }\n\n    /** Parses a list of modifiers, in any order.\n     *  If you need a specific order, you must call this function multiple times:\n     *    this.tsParseModifiers({ modified: node, allowedModifiers: [\"public\"] });\n     *    this.tsParseModifiers({ modified: node, allowedModifiers: [\"abstract\", \"readonly\"] });\n     */\n    tsParseModifiers<N extends ModifierBase>(\n      {\n        allowedModifiers,\n        disallowedModifiers,\n        stopOnStartOfClassStaticBlock,\n        errorTemplate = TSErrors.InvalidModifierOnTypeMember,\n      }: {\n        allowedModifiers: readonly TsModifier[];\n        disallowedModifiers?: TsModifier[];\n        stopOnStartOfClassStaticBlock?: boolean;\n        errorTemplate?: typeof TSErrors.InvalidModifierOnTypeMember;\n      },\n      modified: N,\n    ): void {\n      const enforceOrder = (\n        loc: Position,\n        modifier: TsModifier,\n        before: TsModifier,\n        after: TsModifier,\n      ) => {\n        if (modifier === before && modified[after]) {\n          this.raise(TSErrors.InvalidModifiersOrder, {\n            at: loc,\n            orderedModifiers: [before, after],\n          });\n        }\n      };\n      const incompatible = (\n        loc: Position,\n        modifier: TsModifier,\n        mod1: TsModifier,\n        mod2: TsModifier,\n      ) => {\n        if (\n          (modified[mod1] && modifier === mod2) ||\n          (modified[mod2] && modifier === mod1)\n        ) {\n          this.raise(TSErrors.IncompatibleModifiers, {\n            at: loc,\n            modifiers: [mod1, mod2],\n          });\n        }\n      };\n\n      for (;;) {\n        const { startLoc } = this.state;\n        const modifier: TsModifier | undefined | null = this.tsParseModifier(\n          allowedModifiers.concat(disallowedModifiers ?? []),\n          stopOnStartOfClassStaticBlock,\n        );\n\n        if (!modifier) break;\n\n        if (tsIsAccessModifier(modifier)) {\n          if (modified.accessibility) {\n            this.raise(TSErrors.DuplicateAccessibilityModifier, {\n              at: startLoc,\n              modifier,\n            });\n          } else {\n            enforceOrder(startLoc, modifier, modifier, \"override\");\n            enforceOrder(startLoc, modifier, modifier, \"static\");\n            enforceOrder(startLoc, modifier, modifier, \"readonly\");\n\n            modified.accessibility = modifier;\n          }\n        } else if (tsIsVarianceAnnotations(modifier)) {\n          if (modified[modifier]) {\n            this.raise(TSErrors.DuplicateModifier, { at: startLoc, modifier });\n          }\n          modified[modifier] = true;\n\n          enforceOrder(startLoc, modifier, \"in\", \"out\");\n        } else {\n          if (Object.hasOwnProperty.call(modified, modifier)) {\n            this.raise(TSErrors.DuplicateModifier, { at: startLoc, modifier });\n          } else {\n            enforceOrder(startLoc, modifier, \"static\", \"readonly\");\n            enforceOrder(startLoc, modifier, \"static\", \"override\");\n            enforceOrder(startLoc, modifier, \"override\", \"readonly\");\n            enforceOrder(startLoc, modifier, \"abstract\", \"override\");\n\n            incompatible(startLoc, modifier, \"declare\", \"override\");\n            incompatible(startLoc, modifier, \"static\", \"abstract\");\n          }\n          modified[modifier] = true;\n        }\n\n        if (disallowedModifiers?.includes(modifier)) {\n          this.raise(errorTemplate, {\n            at: startLoc,\n            modifier,\n          });\n        }\n      }\n    }\n\n    tsIsListTerminator(kind: ParsingContext): boolean {\n      switch (kind) {\n        case \"EnumMembers\":\n        case \"TypeMembers\":\n          return this.match(tt.braceR);\n        case \"HeritageClauseElement\":\n          return this.match(tt.braceL);\n        case \"TupleElementTypes\":\n          return this.match(tt.bracketR);\n        case \"TypeParametersOrArguments\":\n          return this.match(tt.gt);\n      }\n    }\n\n    tsParseList<T extends N.Node>(\n      kind: ParsingContext,\n      parseElement: () => T,\n    ): T[] {\n      const result: T[] = [];\n      while (!this.tsIsListTerminator(kind)) {\n        // Skipping \"parseListElement\" from the TS source since that's just for error handling.\n        result.push(parseElement());\n      }\n      return result;\n    }\n\n    tsParseDelimitedList<T extends N.Node>(\n      kind: ParsingContext,\n      parseElement: () => T,\n      refTrailingCommaPos?: {\n        value: number;\n      },\n    ): T[] {\n      return nonNull(\n        this.tsParseDelimitedListWorker(\n          kind,\n          parseElement,\n          /* expectSuccess */ true,\n          refTrailingCommaPos,\n        ),\n      );\n    }\n\n    /**\n     * If !expectSuccess, returns undefined instead of failing to parse.\n     * If expectSuccess, parseElement should always return a defined value.\n     */\n    tsParseDelimitedListWorker<T extends N.Node>(\n      kind: ParsingContext,\n      parseElement: () => T | undefined | null,\n      expectSuccess: boolean,\n      refTrailingCommaPos?: {\n        value: number;\n      },\n    ): T[] | undefined | null {\n      const result = [];\n      let trailingCommaPos = -1;\n\n      for (;;) {\n        if (this.tsIsListTerminator(kind)) {\n          break;\n        }\n        trailingCommaPos = -1;\n\n        const element = parseElement();\n        if (element == null) {\n          return undefined;\n        }\n        result.push(element);\n\n        if (this.eat(tt.comma)) {\n          trailingCommaPos = this.state.lastTokStart;\n          continue;\n        }\n\n        if (this.tsIsListTerminator(kind)) {\n          break;\n        }\n\n        if (expectSuccess) {\n          // This will fail with an error about a missing comma\n          this.expect(tt.comma);\n        }\n        return undefined;\n      }\n\n      if (refTrailingCommaPos) {\n        refTrailingCommaPos.value = trailingCommaPos;\n      }\n\n      return result;\n    }\n\n    tsParseBracketedList<T extends N.Node>(\n      kind: ParsingContext,\n      parseElement: () => T,\n      bracket: boolean,\n      skipFirstToken: boolean,\n      refTrailingCommaPos?: {\n        value: number;\n      },\n    ): T[] {\n      if (!skipFirstToken) {\n        if (bracket) {\n          this.expect(tt.bracketL);\n        } else {\n          this.expect(tt.lt);\n        }\n      }\n\n      const result = this.tsParseDelimitedList(\n        kind,\n        parseElement,\n        refTrailingCommaPos,\n      );\n\n      if (bracket) {\n        this.expect(tt.bracketR);\n      } else {\n        this.expect(tt.gt);\n      }\n\n      return result;\n    }\n\n    tsParseImportType(): N.TsImportType {\n      const node = this.startNode<N.TsImportType>();\n      this.expect(tt._import);\n      this.expect(tt.parenL);\n      if (!this.match(tt.string)) {\n        this.raise(TSErrors.UnsupportedImportTypeArgument, {\n          at: this.state.startLoc,\n        });\n      }\n\n      // For compatibility to estree we cannot call parseLiteral directly here\n      node.argument = super.parseExprAtom() as N.StringLiteral;\n      this.expect(tt.parenR);\n\n      if (this.eat(tt.dot)) {\n        // In this instance, the entity name will actually itself be a\n        // qualifier, so allow it to be a reserved word as well.\n        node.qualifier = this.tsParseEntityName();\n      }\n      if (this.match(tt.lt)) {\n        node.typeParameters = this.tsParseTypeArguments();\n      }\n      return this.finishNode(node, \"TSImportType\");\n    }\n\n    tsParseEntityName(allowReservedWords: boolean = true): N.TsEntityName {\n      let entity: N.TsEntityName = this.parseIdentifier(allowReservedWords);\n      while (this.eat(tt.dot)) {\n        const node: Undone<N.TsQualifiedName> =\n          this.startNodeAtNode<N.TsQualifiedName>(entity);\n        node.left = entity;\n        node.right = this.parseIdentifier(allowReservedWords);\n        entity = this.finishNode(node, \"TSQualifiedName\");\n      }\n      return entity;\n    }\n\n    tsParseTypeReference(): N.TsTypeReference {\n      const node = this.startNode<N.TsTypeReference>();\n      node.typeName = this.tsParseEntityName();\n      if (!this.hasPrecedingLineBreak() && this.match(tt.lt)) {\n        node.typeParameters = this.tsParseTypeArguments();\n      }\n      return this.finishNode(node, \"TSTypeReference\");\n    }\n\n    tsParseThisTypePredicate(lhs: N.TsThisType): N.TsTypePredicate {\n      this.next();\n      const node = this.startNodeAtNode<N.TsTypePredicate>(lhs);\n      node.parameterName = lhs;\n      node.typeAnnotation = this.tsParseTypeAnnotation(/* eatColon */ false);\n      node.asserts = false;\n      return this.finishNode(node, \"TSTypePredicate\");\n    }\n\n    tsParseThisTypeNode(): N.TsThisType {\n      const node = this.startNode<N.TsThisType>();\n      this.next();\n      return this.finishNode(node, \"TSThisType\");\n    }\n\n    tsParseTypeQuery(): N.TsTypeQuery {\n      const node = this.startNode<N.TsTypeQuery>();\n      this.expect(tt._typeof);\n      if (this.match(tt._import)) {\n        node.exprName = this.tsParseImportType();\n      } else {\n        node.exprName = this.tsParseEntityName();\n      }\n      if (!this.hasPrecedingLineBreak() && this.match(tt.lt)) {\n        node.typeParameters = this.tsParseTypeArguments();\n      }\n      return this.finishNode(node, \"TSTypeQuery\");\n    }\n\n    tsParseInOutModifiers = this.tsParseModifiers.bind(this, {\n      allowedModifiers: [\"in\", \"out\"],\n      disallowedModifiers: [\n        \"const\",\n        \"public\",\n        \"private\",\n        \"protected\",\n        \"readonly\",\n        \"declare\",\n        \"abstract\",\n        \"override\",\n      ],\n      errorTemplate: TSErrors.InvalidModifierOnTypeParameter,\n    });\n\n    tsParseConstModifier = this.tsParseModifiers.bind(this, {\n      allowedModifiers: [\"const\"],\n      // for better error recovery\n      disallowedModifiers: [\"in\", \"out\"],\n      errorTemplate: TSErrors.InvalidModifierOnTypeParameterPositions,\n    });\n\n    tsParseInOutConstModifiers = this.tsParseModifiers.bind(this, {\n      allowedModifiers: [\"in\", \"out\", \"const\"],\n      disallowedModifiers: [\n        \"public\",\n        \"private\",\n        \"protected\",\n        \"readonly\",\n        \"declare\",\n        \"abstract\",\n        \"override\",\n      ],\n      errorTemplate: TSErrors.InvalidModifierOnTypeParameter,\n    });\n\n    tsParseTypeParameter(\n      parseModifiers: (node: Undone<N.TsTypeParameter>) => void,\n    ): N.TsTypeParameter {\n      const node = this.startNode<N.TsTypeParameter>();\n\n      parseModifiers(node);\n\n      node.name = this.tsParseTypeParameterName();\n      node.constraint = this.tsEatThenParseType(tt._extends);\n      node.default = this.tsEatThenParseType(tt.eq);\n      return this.finishNode(node, \"TSTypeParameter\");\n    }\n\n    tsTryParseTypeParameters(\n      parseModifiers: (node: N.TsTypeParameter) => void,\n    ): N.TsTypeParameterDeclaration | undefined | null {\n      if (this.match(tt.lt)) {\n        return this.tsParseTypeParameters(parseModifiers);\n      }\n    }\n\n    tsParseTypeParameters(parseModifiers: (node: N.TsTypeParameter) => void) {\n      const node = this.startNode<N.TsTypeParameterDeclaration>();\n\n      if (this.match(tt.lt) || this.match(tt.jsxTagStart)) {\n        this.next();\n      } else {\n        this.unexpected();\n      }\n\n      const refTrailingCommaPos = { value: -1 };\n\n      node.params = this.tsParseBracketedList(\n        \"TypeParametersOrArguments\",\n        // @ts-expect-error refine typings\n        this.tsParseTypeParameter.bind(this, parseModifiers),\n        /* bracket */ false,\n        /* skipFirstToken */ true,\n        refTrailingCommaPos,\n      );\n      if (node.params.length === 0) {\n        this.raise(TSErrors.EmptyTypeParameters, { at: node });\n      }\n      if (refTrailingCommaPos.value !== -1) {\n        this.addExtra(node, \"trailingComma\", refTrailingCommaPos.value);\n      }\n      return this.finishNode(node, \"TSTypeParameterDeclaration\");\n    }\n\n    // Note: In TypeScript implementation we must provide `yieldContext` and `awaitContext`,\n    // but here it's always false, because this is only used for types.\n    tsFillSignature(\n      returnToken: TokenType,\n      signature: Undone<N.TsSignatureDeclaration>,\n    ): void {\n      // Arrow fns *must* have return token (`=>`). Normal functions can omit it.\n      const returnTokenRequired = returnToken === tt.arrow;\n\n      // https://github.com/babel/babel/issues/9231\n      const paramsKey = process.env.BABEL_8_BREAKING ? \"params\" : \"parameters\";\n      const returnTypeKey = process.env.BABEL_8_BREAKING\n        ? \"returnType\"\n        : \"typeAnnotation\";\n\n      signature.typeParameters = this.tsTryParseTypeParameters(\n        this.tsParseConstModifier,\n      );\n      this.expect(tt.parenL);\n      signature[paramsKey] = this.tsParseBindingListForSignature();\n      if (returnTokenRequired) {\n        signature[returnTypeKey] =\n          this.tsParseTypeOrTypePredicateAnnotation(returnToken);\n      } else if (this.match(returnToken)) {\n        signature[returnTypeKey] =\n          this.tsParseTypeOrTypePredicateAnnotation(returnToken);\n      }\n    }\n\n    tsParseBindingListForSignature(): Array<\n      N.Identifier | N.RestElement | N.ObjectPattern | N.ArrayPattern\n    > {\n      const list = super.parseBindingList(\n        tt.parenR,\n        charCodes.rightParenthesis,\n        ParseBindingListFlags.IS_FUNCTION_PARAMS,\n      );\n      for (const pattern of list) {\n        const { type } = pattern;\n        if (type === \"AssignmentPattern\" || type === \"TSParameterProperty\") {\n          this.raise(TSErrors.UnsupportedSignatureParameterKind, {\n            at: pattern,\n            type,\n          });\n        }\n      }\n      return list as Exclude<\n        (typeof list)[0],\n        N.AssignmentPattern | N.TSParameterProperty\n      >[];\n    }\n\n    tsParseTypeMemberSemicolon(): void {\n      if (!this.eat(tt.comma) && !this.isLineTerminator()) {\n        this.expect(tt.semi);\n      }\n    }\n\n    tsParseSignatureMember(\n      kind: \"TSCallSignatureDeclaration\" | \"TSConstructSignatureDeclaration\",\n      node: Undone<\n        N.TsCallSignatureDeclaration | N.TsConstructSignatureDeclaration\n      >,\n    ): N.TsCallSignatureDeclaration | N.TsConstructSignatureDeclaration {\n      this.tsFillSignature(tt.colon, node);\n      this.tsParseTypeMemberSemicolon();\n      return this.finishNode(node, kind);\n    }\n\n    tsIsUnambiguouslyIndexSignature() {\n      this.next(); // Skip '{'\n      if (tokenIsIdentifier(this.state.type)) {\n        this.next();\n        return this.match(tt.colon);\n      }\n      return false;\n    }\n\n    tsTryParseIndexSignature(\n      node: Undone<N.TsIndexSignature>,\n    ): N.TsIndexSignature | undefined {\n      if (\n        !(\n          this.match(tt.bracketL) &&\n          this.tsLookAhead(this.tsIsUnambiguouslyIndexSignature.bind(this))\n        )\n      ) {\n        return;\n      }\n\n      this.expect(tt.bracketL);\n      const id = this.parseIdentifier();\n      id.typeAnnotation = this.tsParseTypeAnnotation();\n      this.resetEndLocation(id); // set end position to end of type\n\n      this.expect(tt.bracketR);\n      node.parameters = [id];\n\n      const type = this.tsTryParseTypeAnnotation();\n      if (type) node.typeAnnotation = type;\n      this.tsParseTypeMemberSemicolon();\n      return this.finishNode(node, \"TSIndexSignature\");\n    }\n\n    tsParsePropertyOrMethodSignature(\n      node: N.TsPropertySignature | N.TsMethodSignature,\n      readonly: boolean,\n    ): N.TsPropertySignature | N.TsMethodSignature {\n      if (this.eat(tt.question)) node.optional = true;\n      const nodeAny: any = node;\n\n      if (this.match(tt.parenL) || this.match(tt.lt)) {\n        if (readonly) {\n          this.raise(TSErrors.ReadonlyForMethodSignature, { at: node });\n        }\n        const method: N.TsMethodSignature = nodeAny;\n        if (method.kind && this.match(tt.lt)) {\n          this.raise(TSErrors.AccesorCannotHaveTypeParameters, {\n            at: this.state.curPosition(),\n          });\n        }\n        this.tsFillSignature(tt.colon, method);\n        this.tsParseTypeMemberSemicolon();\n        const paramsKey = process.env.BABEL_8_BREAKING\n          ? \"params\"\n          : \"parameters\";\n        const returnTypeKey = process.env.BABEL_8_BREAKING\n          ? \"returnType\"\n          : \"typeAnnotation\";\n        if (method.kind === \"get\") {\n          if (method[paramsKey].length > 0) {\n            this.raise(Errors.BadGetterArity, { at: this.state.curPosition() });\n            if (this.isThisParam(method[paramsKey][0])) {\n              this.raise(TSErrors.AccesorCannotDeclareThisParameter, {\n                at: this.state.curPosition(),\n              });\n            }\n          }\n        } else if (method.kind === \"set\") {\n          if (method[paramsKey].length !== 1) {\n            this.raise(Errors.BadSetterArity, { at: this.state.curPosition() });\n          } else {\n            const firstParameter = method[paramsKey][0];\n            if (this.isThisParam(firstParameter)) {\n              this.raise(TSErrors.AccesorCannotDeclareThisParameter, {\n                at: this.state.curPosition(),\n              });\n            }\n            if (\n              firstParameter.type === \"Identifier\" &&\n              firstParameter.optional\n            ) {\n              this.raise(TSErrors.SetAccesorCannotHaveOptionalParameter, {\n                at: this.state.curPosition(),\n              });\n            }\n            if (firstParameter.type === \"RestElement\") {\n              this.raise(TSErrors.SetAccesorCannotHaveRestParameter, {\n                at: this.state.curPosition(),\n              });\n            }\n          }\n          if (method[returnTypeKey]) {\n            this.raise(TSErrors.SetAccesorCannotHaveReturnType, {\n              at: method[returnTypeKey],\n            });\n          }\n        } else {\n          method.kind = \"method\";\n        }\n        return this.finishNode(method, \"TSMethodSignature\");\n      } else {\n        const property: N.TsPropertySignature = nodeAny;\n        if (readonly) property.readonly = true;\n        const type = this.tsTryParseTypeAnnotation();\n        if (type) property.typeAnnotation = type;\n        this.tsParseTypeMemberSemicolon();\n        return this.finishNode(property, \"TSPropertySignature\");\n      }\n    }\n\n    tsParseTypeMember(): N.TsTypeElement {\n      const node: any = this.startNode();\n\n      if (this.match(tt.parenL) || this.match(tt.lt)) {\n        return this.tsParseSignatureMember(\"TSCallSignatureDeclaration\", node);\n      }\n\n      if (this.match(tt._new)) {\n        const id = this.startNode<N.Identifier>();\n        this.next();\n        if (this.match(tt.parenL) || this.match(tt.lt)) {\n          return this.tsParseSignatureMember(\n            \"TSConstructSignatureDeclaration\",\n            node,\n          );\n        } else {\n          node.key = this.createIdentifier(id, \"new\");\n          return this.tsParsePropertyOrMethodSignature(node, false);\n        }\n      }\n\n      this.tsParseModifiers(\n        {\n          allowedModifiers: [\"readonly\"],\n          disallowedModifiers: [\n            \"declare\",\n            \"abstract\",\n            \"private\",\n            \"protected\",\n            \"public\",\n            \"static\",\n            \"override\",\n          ],\n        },\n        node,\n      );\n\n      const idx = this.tsTryParseIndexSignature(node);\n      if (idx) {\n        return idx;\n      }\n\n      super.parsePropertyName(node);\n      if (\n        !node.computed &&\n        node.key.type === \"Identifier\" &&\n        (node.key.name === \"get\" || node.key.name === \"set\") &&\n        this.tsTokenCanFollowModifier()\n      ) {\n        node.kind = node.key.name;\n        super.parsePropertyName(node);\n      }\n      return this.tsParsePropertyOrMethodSignature(node, !!node.readonly);\n    }\n\n    tsParseTypeLiteral(): N.TsTypeLiteral {\n      const node = this.startNode<N.TsTypeLiteral>();\n      node.members = this.tsParseObjectTypeMembers();\n      return this.finishNode(node, \"TSTypeLiteral\");\n    }\n\n    tsParseObjectTypeMembers(): Array<N.TsTypeElement> {\n      this.expect(tt.braceL);\n      const members = this.tsParseList(\n        \"TypeMembers\",\n        this.tsParseTypeMember.bind(this),\n      );\n      this.expect(tt.braceR);\n      return members;\n    }\n\n    tsIsStartOfMappedType(): boolean {\n      this.next();\n      if (this.eat(tt.plusMin)) {\n        return this.isContextual(tt._readonly);\n      }\n      if (this.isContextual(tt._readonly)) {\n        this.next();\n      }\n      if (!this.match(tt.bracketL)) {\n        return false;\n      }\n      this.next();\n      if (!this.tsIsIdentifier()) {\n        return false;\n      }\n      this.next();\n      return this.match(tt._in);\n    }\n\n    tsParseMappedTypeParameter(): N.TsTypeParameter {\n      const node = this.startNode<N.TsTypeParameter>();\n      node.name = this.tsParseTypeParameterName();\n      node.constraint = this.tsExpectThenParseType(tt._in);\n      return this.finishNode(node, \"TSTypeParameter\");\n    }\n\n    tsParseMappedType(): N.TsMappedType {\n      const node = this.startNode<N.TsMappedType>();\n\n      this.expect(tt.braceL);\n\n      if (this.match(tt.plusMin)) {\n        node.readonly = this.state.value;\n        this.next();\n        this.expectContextual(tt._readonly);\n      } else if (this.eatContextual(tt._readonly)) {\n        node.readonly = true;\n      }\n\n      this.expect(tt.bracketL);\n      node.typeParameter = this.tsParseMappedTypeParameter();\n      node.nameType = this.eatContextual(tt._as) ? this.tsParseType() : null;\n\n      this.expect(tt.bracketR);\n\n      if (this.match(tt.plusMin)) {\n        node.optional = this.state.value;\n        this.next();\n        this.expect(tt.question);\n      } else if (this.eat(tt.question)) {\n        node.optional = true;\n      }\n\n      node.typeAnnotation = this.tsTryParseType();\n      this.semicolon();\n      this.expect(tt.braceR);\n\n      return this.finishNode(node, \"TSMappedType\");\n    }\n\n    tsParseTupleType(): N.TsTupleType {\n      const node = this.startNode<N.TsTupleType>();\n      node.elementTypes = this.tsParseBracketedList(\n        \"TupleElementTypes\",\n        this.tsParseTupleElementType.bind(this),\n        /* bracket */ true,\n        /* skipFirstToken */ false,\n      );\n\n      // Validate the elementTypes to ensure that no mandatory elements\n      // follow optional elements\n      let seenOptionalElement = false;\n      let labeledElements: boolean | null = null;\n      node.elementTypes.forEach(elementNode => {\n        const { type } = elementNode;\n\n        if (\n          seenOptionalElement &&\n          type !== \"TSRestType\" &&\n          type !== \"TSOptionalType\" &&\n          !(type === \"TSNamedTupleMember\" && elementNode.optional)\n        ) {\n          this.raise(TSErrors.OptionalTypeBeforeRequired, {\n            at: elementNode,\n          });\n        }\n\n        seenOptionalElement ||=\n          (type === \"TSNamedTupleMember\" && elementNode.optional) ||\n          type === \"TSOptionalType\";\n\n        // When checking labels, check the argument of the spread operator\n        let checkType = type;\n        if (type === \"TSRestType\") {\n          elementNode = elementNode.typeAnnotation;\n          checkType = elementNode.type;\n        }\n\n        const isLabeled = checkType === \"TSNamedTupleMember\";\n        labeledElements ??= isLabeled;\n        if (labeledElements !== isLabeled) {\n          this.raise(TSErrors.MixedLabeledAndUnlabeledElements, {\n            at: elementNode,\n          });\n        }\n      });\n\n      return this.finishNode(node, \"TSTupleType\");\n    }\n\n    tsParseTupleElementType(): N.TsNamedTupleMember | N.TsType {\n      // parses `...TsType[]`\n\n      const { startLoc } = this.state;\n\n      const rest = this.eat(tt.ellipsis);\n\n      let labeled: boolean;\n      let label: N.Identifier;\n      let optional: boolean;\n      let type: N.TsNamedTupleMember | N.TsType;\n\n      const isWord = tokenIsKeywordOrIdentifier(this.state.type);\n      const chAfterWord = isWord ? this.lookaheadCharCode() : null;\n      if (chAfterWord === charCodes.colon) {\n        labeled = true;\n        optional = false;\n        label = this.parseIdentifier(true);\n        this.expect(tt.colon);\n        type = this.tsParseType();\n      } else if (chAfterWord === charCodes.questionMark) {\n        optional = true;\n        const startLoc = this.state.startLoc;\n        const wordName = this.state.value;\n        const typeOrLabel = this.tsParseNonArrayType();\n\n        if (this.lookaheadCharCode() === charCodes.colon) {\n          labeled = true;\n          label = this.createIdentifier(\n            this.startNodeAt<N.Identifier>(startLoc),\n            wordName,\n          );\n          this.expect(tt.question);\n          this.expect(tt.colon);\n          type = this.tsParseType();\n        } else {\n          labeled = false;\n          type = typeOrLabel;\n          this.expect(tt.question);\n        }\n      } else {\n        type = this.tsParseType();\n        optional = this.eat(tt.question);\n        // In this case (labeled === true) could be only in invalid label.\n        // E.g. [x.y:type]\n        // An error is raised while processing node.\n        labeled = this.eat(tt.colon);\n      }\n\n      if (labeled) {\n        let labeledNode: Undone<N.TsNamedTupleMember>;\n        if (label) {\n          labeledNode = this.startNodeAtNode<N.TsNamedTupleMember>(label);\n          labeledNode.optional = optional;\n          labeledNode.label = label;\n          labeledNode.elementType = type;\n\n          if (this.eat(tt.question)) {\n            labeledNode.optional = true;\n            this.raise(TSErrors.TupleOptionalAfterType, {\n              at: this.state.lastTokStartLoc,\n            });\n          }\n        } else {\n          labeledNode = this.startNodeAtNode<N.TsNamedTupleMember>(type);\n          labeledNode.optional = optional;\n          this.raise(TSErrors.InvalidTupleMemberLabel, { at: type });\n          // @ts-expect-error This produces an invalid AST, but at least we don't drop\n          // nodes representing the invalid source.\n          labeledNode.label = type;\n          labeledNode.elementType = this.tsParseType();\n        }\n        type = this.finishNode(labeledNode, \"TSNamedTupleMember\");\n      } else if (optional) {\n        const optionalTypeNode = this.startNodeAtNode<N.TsOptionalType>(type);\n        optionalTypeNode.typeAnnotation = type;\n        type = this.finishNode(optionalTypeNode, \"TSOptionalType\");\n      }\n\n      if (rest) {\n        const restNode = this.startNodeAt<N.TsRestType>(startLoc);\n        restNode.typeAnnotation = type;\n        type = this.finishNode(restNode, \"TSRestType\");\n      }\n\n      return type;\n    }\n\n    tsParseParenthesizedType(): N.TsParenthesizedType {\n      const node = this.startNode<N.TsParenthesizedType>();\n      this.expect(tt.parenL);\n      node.typeAnnotation = this.tsParseType();\n      this.expect(tt.parenR);\n      return this.finishNode(node, \"TSParenthesizedType\");\n    }\n\n    tsParseFunctionOrConstructorType(\n      type: \"TSFunctionType\" | \"TSConstructorType\",\n      abstract?: boolean,\n    ): N.TsFunctionOrConstructorType {\n      const node = this.startNode<\n        N.TsFunctionOrConstructorType | N.TsConstructorType\n      >();\n      if (type === \"TSConstructorType\") {\n        (node as Undone<N.TsConstructorType>).abstract = !!abstract;\n        if (abstract) this.next();\n        this.next(); // eat `new`\n      }\n      this.tsInAllowConditionalTypesContext(() =>\n        this.tsFillSignature(tt.arrow, node),\n      );\n      return this.finishNode(node, type);\n    }\n\n    tsParseLiteralTypeNode(): N.TsLiteralType {\n      const node = this.startNode<N.TsLiteralType>();\n      switch (this.state.type) {\n        case tt.num:\n        case tt.bigint:\n        case tt.string:\n        case tt._true:\n        case tt._false:\n          // For compatibility to estree we cannot call parseLiteral directly here\n          // @ts-expect-error refine typings\n          node.literal = super.parseExprAtom();\n          break;\n        default:\n          this.unexpected();\n      }\n      return this.finishNode(node, \"TSLiteralType\");\n    }\n\n    tsParseTemplateLiteralType(): N.TsType {\n      const node = this.startNode<N.TsLiteralType>();\n      node.literal = super.parseTemplate(false);\n      return this.finishNode(node, \"TSLiteralType\");\n    }\n\n    parseTemplateSubstitution(): N.TsType | N.Node {\n      if (this.state.inType) return this.tsParseType();\n      return super.parseTemplateSubstitution();\n    }\n\n    tsParseThisTypeOrThisTypePredicate(): N.TsThisType | N.TsTypePredicate {\n      const thisKeyword = this.tsParseThisTypeNode();\n      if (this.isContextual(tt._is) && !this.hasPrecedingLineBreak()) {\n        return this.tsParseThisTypePredicate(thisKeyword);\n      } else {\n        return thisKeyword;\n      }\n    }\n\n    tsParseNonArrayType(): N.TsType {\n      switch (this.state.type) {\n        case tt.string:\n        case tt.num:\n        case tt.bigint:\n        case tt._true:\n        case tt._false:\n          return this.tsParseLiteralTypeNode();\n        case tt.plusMin:\n          if (this.state.value === \"-\") {\n            const node = this.startNode<N.TsLiteralType>();\n            const nextToken = this.lookahead();\n            if (nextToken.type !== tt.num && nextToken.type !== tt.bigint) {\n              this.unexpected();\n            }\n            // @ts-expect-error: parseMaybeUnary must returns unary expression\n            node.literal = this.parseMaybeUnary();\n            return this.finishNode(node, \"TSLiteralType\");\n          }\n          break;\n        case tt._this:\n          return this.tsParseThisTypeOrThisTypePredicate();\n        case tt._typeof:\n          return this.tsParseTypeQuery();\n        case tt._import:\n          return this.tsParseImportType();\n        case tt.braceL:\n          return this.tsLookAhead(this.tsIsStartOfMappedType.bind(this))\n            ? this.tsParseMappedType()\n            : this.tsParseTypeLiteral();\n        case tt.bracketL:\n          return this.tsParseTupleType();\n        case tt.parenL:\n          if (process.env.BABEL_8_BREAKING) {\n            if (!this.options.createParenthesizedExpressions) {\n              const startLoc = this.state.startLoc;\n              this.next();\n              const type = this.tsParseType();\n              this.expect(tt.parenR);\n              this.addExtra(type, \"parenthesized\", true);\n              this.addExtra(type, \"parenStart\", startLoc.index);\n              return type;\n            }\n          }\n\n          return this.tsParseParenthesizedType();\n        case tt.templateNonTail:\n        case tt.templateTail:\n          return this.tsParseTemplateLiteralType();\n        default: {\n          const { type } = this.state;\n          if (\n            tokenIsIdentifier(type) ||\n            type === tt._void ||\n            type === tt._null\n          ) {\n            const nodeType =\n              type === tt._void\n                ? \"TSVoidKeyword\"\n                : type === tt._null\n                ? \"TSNullKeyword\"\n                : keywordTypeFromName(this.state.value);\n            if (\n              nodeType !== undefined &&\n              this.lookaheadCharCode() !== charCodes.dot\n            ) {\n              const node = this.startNode<N.TsKeywordType>();\n              this.next();\n              return this.finishNode(node, nodeType);\n            }\n            return this.tsParseTypeReference();\n          }\n        }\n      }\n\n      this.unexpected();\n    }\n\n    tsParseArrayTypeOrHigher(): N.TsType {\n      let type = this.tsParseNonArrayType();\n      while (!this.hasPrecedingLineBreak() && this.eat(tt.bracketL)) {\n        if (this.match(tt.bracketR)) {\n          const node = this.startNodeAtNode<N.TsArrayType>(type);\n          node.elementType = type;\n          this.expect(tt.bracketR);\n          type = this.finishNode(node, \"TSArrayType\");\n        } else {\n          const node = this.startNodeAtNode<N.TsIndexedAccessType>(type);\n          node.objectType = type;\n          node.indexType = this.tsParseType();\n          this.expect(tt.bracketR);\n          type = this.finishNode(node, \"TSIndexedAccessType\");\n        }\n      }\n      return type;\n    }\n\n    tsParseTypeOperator(): N.TsTypeOperator {\n      const node = this.startNode<N.TsTypeOperator>();\n      const operator = this.state.value;\n      this.next(); // eat operator\n      node.operator = operator;\n      node.typeAnnotation = this.tsParseTypeOperatorOrHigher();\n\n      if (operator === \"readonly\") {\n        this.tsCheckTypeAnnotationForReadOnly(\n          // @ts-expect-error todo(flow->ts)\n          node,\n        );\n      }\n\n      return this.finishNode(node, \"TSTypeOperator\");\n    }\n\n    tsCheckTypeAnnotationForReadOnly(node: N.Node) {\n      switch (node.typeAnnotation.type) {\n        case \"TSTupleType\":\n        case \"TSArrayType\":\n          return;\n        default:\n          this.raise(TSErrors.UnexpectedReadonly, { at: node });\n      }\n    }\n\n    tsParseInferType(): N.TsInferType {\n      const node = this.startNode<N.TsInferType>();\n      this.expectContextual(tt._infer);\n      const typeParameter = this.startNode<N.TsTypeParameter>();\n      typeParameter.name = this.tsParseTypeParameterName();\n      typeParameter.constraint = this.tsTryParse(() =>\n        this.tsParseConstraintForInferType(),\n      );\n      node.typeParameter = this.finishNode(typeParameter, \"TSTypeParameter\");\n      return this.finishNode(node, \"TSInferType\");\n    }\n\n    tsParseConstraintForInferType() {\n      if (this.eat(tt._extends)) {\n        const constraint = this.tsInDisallowConditionalTypesContext(() =>\n          this.tsParseType(),\n        );\n        if (\n          this.state.inDisallowConditionalTypesContext ||\n          !this.match(tt.question)\n        ) {\n          return constraint;\n        }\n      }\n    }\n\n    tsParseTypeOperatorOrHigher(): N.TsType {\n      const isTypeOperator =\n        tokenIsTSTypeOperator(this.state.type) && !this.state.containsEsc;\n      return isTypeOperator\n        ? this.tsParseTypeOperator()\n        : this.isContextual(tt._infer)\n        ? this.tsParseInferType()\n        : this.tsInAllowConditionalTypesContext(() =>\n            this.tsParseArrayTypeOrHigher(),\n          );\n    }\n\n    tsParseUnionOrIntersectionType(\n      kind: \"TSUnionType\" | \"TSIntersectionType\",\n      parseConstituentType: () => N.TsType,\n      operator: TokenType,\n    ): N.TsType {\n      const node = this.startNode<N.TsUnionType | N.TsIntersectionType>();\n      const hasLeadingOperator = this.eat(operator);\n      const types = [];\n      do {\n        types.push(parseConstituentType());\n      } while (this.eat(operator));\n      if (types.length === 1 && !hasLeadingOperator) {\n        return types[0];\n      }\n      node.types = types;\n      return this.finishNode(node, kind);\n    }\n\n    tsParseIntersectionTypeOrHigher(): N.TsType {\n      return this.tsParseUnionOrIntersectionType(\n        \"TSIntersectionType\",\n        this.tsParseTypeOperatorOrHigher.bind(this),\n        tt.bitwiseAND,\n      );\n    }\n\n    tsParseUnionTypeOrHigher() {\n      return this.tsParseUnionOrIntersectionType(\n        \"TSUnionType\",\n        this.tsParseIntersectionTypeOrHigher.bind(this),\n        tt.bitwiseOR,\n      );\n    }\n\n    tsIsStartOfFunctionType() {\n      if (this.match(tt.lt)) {\n        return true;\n      }\n      return (\n        this.match(tt.parenL) &&\n        this.tsLookAhead(this.tsIsUnambiguouslyStartOfFunctionType.bind(this))\n      );\n    }\n\n    tsSkipParameterStart(): boolean {\n      if (tokenIsIdentifier(this.state.type) || this.match(tt._this)) {\n        this.next();\n        return true;\n      }\n\n      if (this.match(tt.braceL)) {\n        // Return true if we can parse an object pattern without errors\n        const { errors } = this.state;\n        const previousErrorCount = errors.length;\n        try {\n          this.parseObjectLike(tt.braceR, true);\n          return errors.length === previousErrorCount;\n        } catch {\n          return false;\n        }\n      }\n\n      if (this.match(tt.bracketL)) {\n        this.next();\n        // Return true if we can parse an array pattern without errors\n        const { errors } = this.state;\n        const previousErrorCount = errors.length;\n        try {\n          super.parseBindingList(\n            tt.bracketR,\n            charCodes.rightSquareBracket,\n            ParseBindingListFlags.ALLOW_EMPTY,\n          );\n          return errors.length === previousErrorCount;\n        } catch {\n          return false;\n        }\n      }\n\n      return false;\n    }\n\n    tsIsUnambiguouslyStartOfFunctionType(): boolean {\n      this.next();\n      if (this.match(tt.parenR) || this.match(tt.ellipsis)) {\n        // ( )\n        // ( ...\n        return true;\n      }\n      if (this.tsSkipParameterStart()) {\n        if (\n          this.match(tt.colon) ||\n          this.match(tt.comma) ||\n          this.match(tt.question) ||\n          this.match(tt.eq)\n        ) {\n          // ( xxx :\n          // ( xxx ,\n          // ( xxx ?\n          // ( xxx =\n          return true;\n        }\n        if (this.match(tt.parenR)) {\n          this.next();\n          if (this.match(tt.arrow)) {\n            // ( xxx ) =>\n            return true;\n          }\n        }\n      }\n      return false;\n    }\n\n    tsParseTypeOrTypePredicateAnnotation(\n      returnToken: TokenType,\n    ): N.TsTypeAnnotation {\n      return this.tsInType(() => {\n        const t = this.startNode<N.TsTypeAnnotation>();\n        this.expect(returnToken);\n\n        const node = this.startNode<N.TsTypePredicate>();\n\n        const asserts = !!this.tsTryParse(\n          this.tsParseTypePredicateAsserts.bind(this),\n        );\n\n        if (asserts && this.match(tt._this)) {\n          // When asserts is false, thisKeyword is handled by tsParseNonArrayType\n          // : asserts this is type\n          let thisTypePredicate = this.tsParseThisTypeOrThisTypePredicate();\n          // if it turns out to be a `TSThisType`, wrap it with `TSTypePredicate`\n          // : asserts this\n          if (thisTypePredicate.type === \"TSThisType\") {\n            node.parameterName = thisTypePredicate;\n            node.asserts = true;\n            (node as N.TsTypePredicate).typeAnnotation = null;\n            thisTypePredicate = this.finishNode(node, \"TSTypePredicate\");\n          } else {\n            this.resetStartLocationFromNode(thisTypePredicate, node);\n            thisTypePredicate.asserts = true;\n          }\n          t.typeAnnotation = thisTypePredicate;\n          return this.finishNode(t, \"TSTypeAnnotation\");\n        }\n\n        const typePredicateVariable =\n          this.tsIsIdentifier() &&\n          this.tsTryParse(this.tsParseTypePredicatePrefix.bind(this));\n\n        if (!typePredicateVariable) {\n          if (!asserts) {\n            // : type\n            return this.tsParseTypeAnnotation(/* eatColon */ false, t);\n          }\n\n          // : asserts foo\n          node.parameterName = this.parseIdentifier();\n          node.asserts = asserts;\n          (node as N.TsTypePredicate).typeAnnotation = null;\n          t.typeAnnotation = this.finishNode(node, \"TSTypePredicate\");\n          return this.finishNode(t, \"TSTypeAnnotation\");\n        }\n\n        // : asserts foo is type\n        const type = this.tsParseTypeAnnotation(/* eatColon */ false);\n        node.parameterName = typePredicateVariable;\n        node.typeAnnotation = type;\n        node.asserts = asserts;\n        t.typeAnnotation = this.finishNode(node, \"TSTypePredicate\");\n        return this.finishNode(t, \"TSTypeAnnotation\");\n      });\n    }\n\n    tsTryParseTypeOrTypePredicateAnnotation(): N.TsTypeAnnotation | undefined {\n      if (this.match(tt.colon)) {\n        return this.tsParseTypeOrTypePredicateAnnotation(tt.colon);\n      }\n    }\n\n    tsTryParseTypeAnnotation(): N.TsTypeAnnotation | undefined {\n      if (this.match(tt.colon)) {\n        return this.tsParseTypeAnnotation();\n      }\n    }\n\n    tsTryParseType(): N.TsType | undefined {\n      return this.tsEatThenParseType(tt.colon);\n    }\n\n    tsParseTypePredicatePrefix(): N.Identifier | undefined {\n      const id = this.parseIdentifier();\n      if (this.isContextual(tt._is) && !this.hasPrecedingLineBreak()) {\n        this.next();\n        return id;\n      }\n    }\n\n    tsParseTypePredicateAsserts(): boolean {\n      if (this.state.type !== tt._asserts) {\n        return false;\n      }\n      const containsEsc = this.state.containsEsc;\n      this.next();\n      if (!tokenIsIdentifier(this.state.type) && !this.match(tt._this)) {\n        return false;\n      }\n\n      if (containsEsc) {\n        this.raise(Errors.InvalidEscapedReservedWord, {\n          at: this.state.lastTokStartLoc,\n          reservedWord: \"asserts\",\n        });\n      }\n\n      return true;\n    }\n\n    tsParseTypeAnnotation(\n      eatColon = true,\n      t: Undone<N.TsTypeAnnotation> = this.startNode<N.TsTypeAnnotation>(),\n    ): N.TsTypeAnnotation {\n      this.tsInType(() => {\n        if (eatColon) this.expect(tt.colon);\n        t.typeAnnotation = this.tsParseType();\n      });\n      return this.finishNode(t, \"TSTypeAnnotation\");\n    }\n\n    /** Be sure to be in a type context before calling this, using `tsInType`. */\n    tsParseType(): N.TsType {\n      // Need to set `state.inType` so that we don't parse JSX in a type context.\n      assert(this.state.inType);\n      const type = this.tsParseNonConditionalType();\n\n      if (\n        this.state.inDisallowConditionalTypesContext ||\n        this.hasPrecedingLineBreak() ||\n        !this.eat(tt._extends)\n      ) {\n        return type;\n      }\n      const node = this.startNodeAtNode<N.TsConditionalType>(type);\n      node.checkType = type;\n\n      node.extendsType = this.tsInDisallowConditionalTypesContext(() =>\n        this.tsParseNonConditionalType(),\n      );\n\n      this.expect(tt.question);\n      node.trueType = this.tsInAllowConditionalTypesContext(() =>\n        this.tsParseType(),\n      );\n\n      this.expect(tt.colon);\n      node.falseType = this.tsInAllowConditionalTypesContext(() =>\n        this.tsParseType(),\n      );\n\n      return this.finishNode(node, \"TSConditionalType\");\n    }\n\n    isAbstractConstructorSignature(): boolean {\n      return (\n        this.isContextual(tt._abstract) && this.lookahead().type === tt._new\n      );\n    }\n\n    tsParseNonConditionalType(): N.TsType {\n      if (this.tsIsStartOfFunctionType()) {\n        return this.tsParseFunctionOrConstructorType(\"TSFunctionType\");\n      }\n      if (this.match(tt._new)) {\n        // As in `new () => Date`\n        return this.tsParseFunctionOrConstructorType(\"TSConstructorType\");\n      } else if (this.isAbstractConstructorSignature()) {\n        // As in `abstract new () => Date`\n        return this.tsParseFunctionOrConstructorType(\n          \"TSConstructorType\",\n          /* abstract */ true,\n        );\n      }\n      return this.tsParseUnionTypeOrHigher();\n    }\n\n    tsParseTypeAssertion(): N.TsTypeAssertion {\n      if (this.getPluginOption(\"typescript\", \"disallowAmbiguousJSXLike\")) {\n        this.raise(TSErrors.ReservedTypeAssertion, { at: this.state.startLoc });\n      }\n\n      const node = this.startNode<N.TsTypeAssertion>();\n      node.typeAnnotation = this.tsInType(() => {\n        this.next(); // \"<\"\n        return this.match(tt._const)\n          ? this.tsParseTypeReference()\n          : this.tsParseType();\n      });\n      this.expect(tt.gt);\n      node.expression = this.parseMaybeUnary();\n      return this.finishNode(node, \"TSTypeAssertion\");\n    }\n\n    tsParseHeritageClause(\n      token: \"extends\" | \"implements\",\n    ): Array<N.TsExpressionWithTypeArguments> {\n      const originalStartLoc = this.state.startLoc;\n\n      const delimitedList = this.tsParseDelimitedList(\n        \"HeritageClauseElement\",\n        () => {\n          const node = this.startNode<N.TsExpressionWithTypeArguments>();\n          node.expression = this.tsParseEntityName();\n          if (this.match(tt.lt)) {\n            node.typeParameters = this.tsParseTypeArguments();\n          }\n\n          return this.finishNode(node, \"TSExpressionWithTypeArguments\");\n        },\n      );\n\n      if (!delimitedList.length) {\n        this.raise(TSErrors.EmptyHeritageClauseType, {\n          at: originalStartLoc,\n          token,\n        });\n      }\n\n      return delimitedList;\n    }\n\n    tsParseInterfaceDeclaration(\n      node: Undone<N.TsInterfaceDeclaration>,\n      properties: {\n        declare?: true;\n      } = {},\n    ): N.TsInterfaceDeclaration | null {\n      if (this.hasFollowingLineBreak()) return null;\n      this.expectContextual(tt._interface);\n      if (properties.declare) node.declare = true;\n      if (tokenIsIdentifier(this.state.type)) {\n        node.id = this.parseIdentifier();\n        this.checkIdentifier(node.id, BIND_TS_INTERFACE);\n      } else {\n        node.id = null;\n        this.raise(TSErrors.MissingInterfaceName, { at: this.state.startLoc });\n      }\n\n      node.typeParameters = this.tsTryParseTypeParameters(\n        this.tsParseInOutConstModifiers,\n      );\n      if (this.eat(tt._extends)) {\n        node.extends = this.tsParseHeritageClause(\"extends\");\n      }\n      const body = this.startNode<N.TSInterfaceBody>();\n      body.body = this.tsInType(this.tsParseObjectTypeMembers.bind(this));\n      node.body = this.finishNode(body, \"TSInterfaceBody\");\n      return this.finishNode(node, \"TSInterfaceDeclaration\");\n    }\n\n    tsParseTypeAliasDeclaration(\n      node: N.TsTypeAliasDeclaration,\n    ): N.TsTypeAliasDeclaration {\n      node.id = this.parseIdentifier();\n      this.checkIdentifier(node.id, BIND_TS_TYPE);\n\n      node.typeAnnotation = this.tsInType(() => {\n        node.typeParameters = this.tsTryParseTypeParameters(\n          this.tsParseInOutModifiers,\n        );\n\n        this.expect(tt.eq);\n\n        if (\n          this.isContextual(tt._intrinsic) &&\n          this.lookahead().type !== tt.dot\n        ) {\n          const node = this.startNode<N.TsKeywordType>();\n          this.next();\n          return this.finishNode(node, \"TSIntrinsicKeyword\");\n        }\n\n        return this.tsParseType();\n      });\n\n      this.semicolon();\n      return this.finishNode(node, \"TSTypeAliasDeclaration\");\n    }\n\n    tsInNoContext<T>(cb: () => T): T {\n      const oldContext = this.state.context;\n      this.state.context = [oldContext[0]];\n      try {\n        return cb();\n      } finally {\n        this.state.context = oldContext;\n      }\n    }\n\n    /**\n     * Runs `cb` in a type context.\n     * This should be called one token *before* the first type token,\n     * so that the call to `next()` is run in type context.\n     */\n    tsInType<T>(cb: () => T): T {\n      const oldInType = this.state.inType;\n      this.state.inType = true;\n      try {\n        return cb();\n      } finally {\n        this.state.inType = oldInType;\n      }\n    }\n\n    tsInDisallowConditionalTypesContext<T>(cb: () => T): T {\n      const oldInDisallowConditionalTypesContext =\n        this.state.inDisallowConditionalTypesContext;\n      this.state.inDisallowConditionalTypesContext = true;\n      try {\n        return cb();\n      } finally {\n        this.state.inDisallowConditionalTypesContext =\n          oldInDisallowConditionalTypesContext;\n      }\n    }\n\n    tsInAllowConditionalTypesContext<T>(cb: () => T): T {\n      const oldInDisallowConditionalTypesContext =\n        this.state.inDisallowConditionalTypesContext;\n      this.state.inDisallowConditionalTypesContext = false;\n      try {\n        return cb();\n      } finally {\n        this.state.inDisallowConditionalTypesContext =\n          oldInDisallowConditionalTypesContext;\n      }\n    }\n\n    tsEatThenParseType(token: TokenType): N.TsType | undefined {\n      if (this.match(token)) {\n        return this.tsNextThenParseType();\n      }\n    }\n\n    tsExpectThenParseType(token: TokenType): N.TsType {\n      return this.tsInType(() => {\n        this.expect(token);\n        return this.tsParseType();\n      });\n    }\n\n    tsNextThenParseType(): N.TsType {\n      return this.tsInType(() => {\n        this.next();\n        return this.tsParseType();\n      });\n    }\n\n    tsParseEnumMember(): N.TsEnumMember {\n      const node = this.startNode<N.TsEnumMember>();\n      // Computed property names are grammar errors in an enum, so accept just string literal or identifier.\n      node.id = this.match(tt.string)\n        ? super.parseStringLiteral(this.state.value)\n        : this.parseIdentifier(/* liberal */ true);\n      if (this.eat(tt.eq)) {\n        node.initializer = super.parseMaybeAssignAllowIn();\n      }\n      return this.finishNode(node, \"TSEnumMember\");\n    }\n\n    tsParseEnumDeclaration(\n      node: Undone<N.TsEnumDeclaration>,\n      properties: {\n        const?: true;\n        declare?: true;\n      } = {},\n    ): N.TsEnumDeclaration {\n      if (properties.const) node.const = true;\n      if (properties.declare) node.declare = true;\n      this.expectContextual(tt._enum);\n      node.id = this.parseIdentifier();\n      this.checkIdentifier(\n        node.id,\n        node.const ? BIND_TS_CONST_ENUM : BIND_TS_ENUM,\n      );\n\n      this.expect(tt.braceL);\n      node.members = this.tsParseDelimitedList(\n        \"EnumMembers\",\n        this.tsParseEnumMember.bind(this),\n      );\n      this.expect(tt.braceR);\n      return this.finishNode(node, \"TSEnumDeclaration\");\n    }\n\n    tsParseModuleBlock(): N.TsModuleBlock {\n      const node = this.startNode<N.TsModuleBlock>();\n      this.scope.enter(SCOPE_OTHER);\n\n      this.expect(tt.braceL);\n      // Inside of a module block is considered \"top-level\", meaning it can have imports and exports.\n      super.parseBlockOrModuleBlockBody(\n        (node.body = []),\n        /* directives */ undefined,\n        /* topLevel */ true,\n        /* end */ tt.braceR,\n      );\n      this.scope.exit();\n      return this.finishNode(node, \"TSModuleBlock\");\n    }\n\n    tsParseModuleOrNamespaceDeclaration(\n      node: Undone<N.TsModuleDeclaration>,\n      nested: boolean = false,\n    ): N.TsModuleDeclaration {\n      node.id = this.parseIdentifier();\n\n      if (!nested) {\n        this.checkIdentifier(node.id, BIND_TS_NAMESPACE);\n      }\n\n      if (this.eat(tt.dot)) {\n        const inner = this.startNode<N.TsModuleDeclaration>();\n        this.tsParseModuleOrNamespaceDeclaration(inner, true);\n        // @ts-expect-error Fixme: refine typings\n        node.body = inner;\n      } else {\n        this.scope.enter(SCOPE_TS_MODULE);\n        this.prodParam.enter(PARAM);\n        node.body = this.tsParseModuleBlock();\n        this.prodParam.exit();\n        this.scope.exit();\n      }\n      return this.finishNode(node, \"TSModuleDeclaration\");\n    }\n\n    tsParseAmbientExternalModuleDeclaration(\n      node: N.TsModuleDeclaration,\n    ): N.TsModuleDeclaration {\n      if (this.isContextual(tt._global)) {\n        node.global = true;\n        node.id = this.parseIdentifier();\n      } else if (this.match(tt.string)) {\n        node.id = super.parseStringLiteral(this.state.value);\n      } else {\n        this.unexpected();\n      }\n      if (this.match(tt.braceL)) {\n        this.scope.enter(SCOPE_TS_MODULE);\n        this.prodParam.enter(PARAM);\n        node.body = this.tsParseModuleBlock();\n        this.prodParam.exit();\n        this.scope.exit();\n      } else {\n        this.semicolon();\n      }\n\n      return this.finishNode(node, \"TSModuleDeclaration\");\n    }\n\n    tsParseImportEqualsDeclaration(\n      node: Undone<N.TsImportEqualsDeclaration>,\n      maybeDefaultIdentifier?: N.Identifier | null,\n      isExport?: boolean,\n    ): N.TsImportEqualsDeclaration {\n      node.isExport = isExport || false;\n      node.id = maybeDefaultIdentifier || this.parseIdentifier();\n      this.checkIdentifier(node.id, BIND_FLAGS_TS_IMPORT);\n      this.expect(tt.eq);\n      const moduleReference = this.tsParseModuleReference();\n      if (\n        node.importKind === \"type\" &&\n        moduleReference.type !== \"TSExternalModuleReference\"\n      ) {\n        this.raise(TSErrors.ImportAliasHasImportType, {\n          at: moduleReference,\n        });\n      }\n      node.moduleReference = moduleReference;\n      this.semicolon();\n      return this.finishNode(node, \"TSImportEqualsDeclaration\");\n    }\n\n    tsIsExternalModuleReference(): boolean {\n      return (\n        this.isContextual(tt._require) &&\n        this.lookaheadCharCode() === charCodes.leftParenthesis\n      );\n    }\n\n    tsParseModuleReference(): N.TsModuleReference {\n      return this.tsIsExternalModuleReference()\n        ? this.tsParseExternalModuleReference()\n        : this.tsParseEntityName(/* allowReservedWords */ false);\n    }\n\n    tsParseExternalModuleReference(): N.TsExternalModuleReference {\n      const node = this.startNode<N.TsExternalModuleReference>();\n      this.expectContextual(tt._require);\n      this.expect(tt.parenL);\n      if (!this.match(tt.string)) {\n        this.unexpected();\n      }\n      // For compatibility to estree we cannot call parseLiteral directly here\n      node.expression = super.parseExprAtom() as N.StringLiteral;\n      this.expect(tt.parenR);\n      this.sawUnambiguousESM = true;\n      return this.finishNode(node, \"TSExternalModuleReference\");\n    }\n\n    // Utilities\n\n    tsLookAhead<T>(f: () => T): T {\n      const state = this.state.clone();\n      const res = f();\n      this.state = state;\n      return res;\n    }\n\n    tsTryParseAndCatch<T extends N.NodeBase | undefined | null>(\n      f: () => T,\n    ): T | undefined | null {\n      const result = this.tryParse(\n        abort =>\n          // @ts-expect-error todo(flow->ts)\n          f() || abort(),\n      );\n\n      if (result.aborted || !result.node) return;\n      if (result.error) this.state = result.failState;\n      // @ts-expect-error refine typings\n      return result.node;\n    }\n\n    tsTryParse<T>(f: () => T | undefined | false): T | undefined {\n      const state = this.state.clone();\n      const result = f();\n      if (result !== undefined && result !== false) {\n        return result;\n      }\n      this.state = state;\n    }\n\n    tsTryParseDeclare(nany: any): N.Declaration | undefined {\n      if (this.isLineTerminator()) {\n        return;\n      }\n      let startType = this.state.type;\n      let kind: \"let\" | null;\n\n      if (this.isContextual(tt._let)) {\n        startType = tt._var;\n        kind = \"let\";\n      }\n\n      // @ts-expect-error refine typings\n      return this.tsInAmbientContext(() => {\n        switch (startType) {\n          case tt._function:\n            nany.declare = true;\n            return super.parseFunctionStatement(\n              nany,\n              /* async */ false,\n              /* isHangingDeclaration */ false,\n            );\n          case tt._class:\n            // While this is also set by tsParseExpressionStatement, we need to set it\n            // before parsing the class declaration to know how to register it in the scope.\n            nany.declare = true;\n            return this.parseClass(\n              nany,\n              /* isStatement */ true,\n              /* optionalId */ false,\n            );\n          case tt._enum:\n            return this.tsParseEnumDeclaration(nany, { declare: true });\n          case tt._global:\n            return this.tsParseAmbientExternalModuleDeclaration(nany);\n          case tt._const:\n          case tt._var:\n            if (!this.match(tt._const) || !this.isLookaheadContextual(\"enum\")) {\n              nany.declare = true;\n              return this.parseVarStatement(\n                nany,\n                kind || this.state.value,\n                true,\n              );\n            }\n\n            // `const enum = 0;` not allowed because \"enum\" is a strict mode reserved word.\n            this.expect(tt._const);\n            return this.tsParseEnumDeclaration(nany, {\n              const: true,\n              declare: true,\n            });\n          case tt._interface: {\n            const result = this.tsParseInterfaceDeclaration(nany, {\n              declare: true,\n            });\n            if (result) return result;\n          }\n          // fallthrough\n          default:\n            if (tokenIsIdentifier(startType)) {\n              return this.tsParseDeclaration(\n                nany,\n                this.state.value,\n                /* next */ true,\n                /* decorators */ null,\n              );\n            }\n        }\n      });\n    }\n\n    // Note: this won't be called unless the keyword is allowed in `shouldParseExportDeclaration`.\n    tsTryParseExportDeclaration(): N.Declaration | undefined {\n      return this.tsParseDeclaration(\n        this.startNode(),\n        this.state.value,\n        /* next */ true,\n        /* decorators */ null,\n      );\n    }\n\n    tsParseExpressionStatement(\n      node: Undone<N.TsModuleDeclaration>,\n      expr: N.Identifier,\n      decorators: N.Decorator[] | null,\n    ): N.Declaration | undefined {\n      switch (expr.name) {\n        case \"declare\": {\n          const declaration = this.tsTryParseDeclare(node);\n          if (declaration) {\n            declaration.declare = true;\n          }\n          return declaration;\n        }\n        case \"global\":\n          // `global { }` (with no `declare`) may appear inside an ambient module declaration.\n          // Would like to use tsParseAmbientExternalModuleDeclaration here, but already ran past \"global\".\n          if (this.match(tt.braceL)) {\n            this.scope.enter(SCOPE_TS_MODULE);\n            this.prodParam.enter(PARAM);\n            const mod = node;\n            mod.global = true;\n            mod.id = expr;\n            mod.body = this.tsParseModuleBlock();\n            this.scope.exit();\n            this.prodParam.exit();\n            return this.finishNode(mod, \"TSModuleDeclaration\");\n          }\n          break;\n\n        default:\n          return this.tsParseDeclaration(\n            node,\n            expr.name,\n            /* next */ false,\n            decorators,\n          );\n      }\n    }\n\n    // Common to tsTryParseDeclare, tsTryParseExportDeclaration, and tsParseExpressionStatement.\n    tsParseDeclaration(\n      node: any,\n      value: string,\n      next: boolean,\n      decorators: N.Decorator[] | null,\n    ): N.Declaration | undefined | null {\n      // no declaration apart from enum can be followed by a line break.\n      switch (value) {\n        case \"abstract\":\n          if (\n            this.tsCheckLineTerminator(next) &&\n            (this.match(tt._class) || tokenIsIdentifier(this.state.type))\n          ) {\n            return this.tsParseAbstractDeclaration(node, decorators);\n          }\n          break;\n\n        case \"module\":\n          if (this.tsCheckLineTerminator(next)) {\n            if (this.match(tt.string)) {\n              return this.tsParseAmbientExternalModuleDeclaration(node);\n            } else if (tokenIsIdentifier(this.state.type)) {\n              return this.tsParseModuleOrNamespaceDeclaration(node);\n            }\n          }\n          break;\n\n        case \"namespace\":\n          if (\n            this.tsCheckLineTerminator(next) &&\n            tokenIsIdentifier(this.state.type)\n          ) {\n            return this.tsParseModuleOrNamespaceDeclaration(node);\n          }\n          break;\n\n        case \"type\":\n          if (\n            this.tsCheckLineTerminator(next) &&\n            tokenIsIdentifier(this.state.type)\n          ) {\n            return this.tsParseTypeAliasDeclaration(node);\n          }\n          break;\n      }\n    }\n\n    tsCheckLineTerminator(next: boolean) {\n      if (next) {\n        if (this.hasFollowingLineBreak()) return false;\n        this.next();\n        return true;\n      }\n      return !this.isLineTerminator();\n    }\n\n    tsTryParseGenericAsyncArrowFunction(\n      startLoc: Position,\n    ): N.ArrowFunctionExpression | undefined {\n      if (!this.match(tt.lt)) return;\n\n      const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;\n      this.state.maybeInArrowParameters = true;\n\n      const res: Undone<N.ArrowFunctionExpression> | undefined =\n        this.tsTryParseAndCatch(() => {\n          const node = this.startNodeAt<N.ArrowFunctionExpression>(startLoc);\n          node.typeParameters = this.tsParseTypeParameters(\n            this.tsParseConstModifier,\n          );\n          // Don't use overloaded parseFunctionParams which would look for \"<\" again.\n          super.parseFunctionParams(node);\n          node.returnType = this.tsTryParseTypeOrTypePredicateAnnotation();\n          this.expect(tt.arrow);\n          return node;\n        });\n\n      this.state.maybeInArrowParameters = oldMaybeInArrowParameters;\n\n      if (!res) return;\n\n      return super.parseArrowExpression(\n        res,\n        /* params are already set */ null,\n        /* async */ true,\n      );\n    }\n\n    // Used when parsing type arguments from ES productions, where the first token\n    // has been created without state.inType. Thus we need to rescan the lt token.\n    tsParseTypeArgumentsInExpression(): N.TsTypeParameterInstantiation | void {\n      if (this.reScan_lt() !== tt.lt) return;\n      return this.tsParseTypeArguments();\n    }\n\n    tsParseTypeArguments(): N.TsTypeParameterInstantiation {\n      const node = this.startNode<N.TsTypeParameterInstantiation>();\n      node.params = this.tsInType(() =>\n        // Temporarily remove a JSX parsing context, which makes us scan different tokens.\n        this.tsInNoContext(() => {\n          this.expect(tt.lt);\n          return this.tsParseDelimitedList(\n            \"TypeParametersOrArguments\",\n            this.tsParseType.bind(this),\n          );\n        }),\n      );\n      if (node.params.length === 0) {\n        this.raise(TSErrors.EmptyTypeArguments, { at: node });\n      } else if (!this.state.inType && this.curContext() === tc.brace) {\n        // rescan `>` when we are no longer in type context and JSX parsing context\n        // since it was tokenized when `inType` is `true`.\n        this.reScan_lt_gt();\n      }\n      this.expect(tt.gt);\n      return this.finishNode(node, \"TSTypeParameterInstantiation\");\n    }\n\n    tsIsDeclarationStart(): boolean {\n      return tokenIsTSDeclarationStart(this.state.type);\n    }\n\n    // ======================================================\n    // OVERRIDES\n    // ======================================================\n\n    isExportDefaultSpecifier(): boolean {\n      if (this.tsIsDeclarationStart()) return false;\n      return super.isExportDefaultSpecifier();\n    }\n\n    parseAssignableListItem(\n      flags: ParseBindingListFlags,\n      decorators: N.Decorator[],\n    ): N.Pattern | N.TSParameterProperty {\n      // Store original location to include modifiers in range\n      const startLoc = this.state.startLoc;\n\n      const modified: ModifierBase = {};\n      this.tsParseModifiers(\n        {\n          allowedModifiers: [\n            \"public\",\n            \"private\",\n            \"protected\",\n            \"override\",\n            \"readonly\",\n          ],\n        },\n        modified,\n      );\n      const accessibility = modified.accessibility;\n      const override = modified.override;\n      const readonly = modified.readonly;\n      if (\n        !(flags & ParseBindingListFlags.IS_CONSTRUCTOR_PARAMS) &&\n        (accessibility || readonly || override)\n      ) {\n        this.raise(TSErrors.UnexpectedParameterModifier, { at: startLoc });\n      }\n\n      const left = this.parseMaybeDefault();\n      this.parseAssignableListItemTypes(left, flags);\n      const elt = this.parseMaybeDefault(left.loc.start, left);\n      if (accessibility || readonly || override) {\n        const pp = this.startNodeAt<N.TSParameterProperty>(startLoc);\n        if (decorators.length) {\n          pp.decorators = decorators;\n        }\n        if (accessibility) pp.accessibility = accessibility;\n        if (readonly) pp.readonly = readonly;\n        if (override) pp.override = override;\n        if (elt.type !== \"Identifier\" && elt.type !== \"AssignmentPattern\") {\n          this.raise(TSErrors.UnsupportedParameterPropertyKind, { at: pp });\n        }\n        pp.parameter = elt as any as N.Identifier | N.AssignmentPattern;\n        return this.finishNode(pp, \"TSParameterProperty\");\n      }\n\n      if (decorators.length) {\n        left.decorators = decorators;\n      }\n\n      return elt;\n    }\n\n    isSimpleParameter(node: N.Pattern | N.TSParameterProperty) {\n      return (\n        (node.type === \"TSParameterProperty\" &&\n          super.isSimpleParameter(node.parameter)) ||\n        super.isSimpleParameter(node)\n      );\n    }\n\n    tsDisallowOptionalPattern(node: Undone<N.Function>) {\n      for (const param of node.params) {\n        if (\n          param.type !== \"Identifier\" &&\n          (param as any).optional &&\n          !this.state.isAmbientContext\n        ) {\n          this.raise(TSErrors.PatternIsOptional, { at: param });\n        }\n      }\n    }\n\n    setArrowFunctionParameters(\n      node: Undone<N.ArrowFunctionExpression>,\n      params: N.Expression[],\n      trailingCommaLoc?: Position | null,\n    ): void {\n      super.setArrowFunctionParameters(node, params, trailingCommaLoc);\n      this.tsDisallowOptionalPattern(node);\n    }\n\n    parseFunctionBodyAndFinish<\n      T extends\n        | N.Function\n        | N.TSDeclareMethod\n        | N.TSDeclareFunction\n        | N.ClassPrivateMethod,\n    >(node: Undone<T>, type: T[\"type\"], isMethod: boolean = false): T {\n      if (this.match(tt.colon)) {\n        node.returnType = this.tsParseTypeOrTypePredicateAnnotation(tt.colon);\n      }\n\n      const bodilessType =\n        type === \"FunctionDeclaration\"\n          ? \"TSDeclareFunction\"\n          : type === \"ClassMethod\" || type === \"ClassPrivateMethod\"\n          ? \"TSDeclareMethod\"\n          : undefined;\n      if (bodilessType && !this.match(tt.braceL) && this.isLineTerminator()) {\n        return this.finishNode(node, bodilessType);\n      }\n      if (bodilessType === \"TSDeclareFunction\" && this.state.isAmbientContext) {\n        this.raise(TSErrors.DeclareFunctionHasImplementation, { at: node });\n        if ((node as Undone<N.FunctionDeclaration>).declare) {\n          return super.parseFunctionBodyAndFinish(node, bodilessType, isMethod);\n        }\n      }\n      this.tsDisallowOptionalPattern(node);\n\n      return super.parseFunctionBodyAndFinish(node, type, isMethod);\n    }\n\n    registerFunctionStatementId(node: N.Function): void {\n      if (!node.body && node.id) {\n        // Function ids are validated after parsing their body.\n        // For bodiless function, we need to do it here.\n        this.checkIdentifier(node.id, BIND_TS_AMBIENT);\n      } else {\n        super.registerFunctionStatementId(node);\n      }\n    }\n\n    tsCheckForInvalidTypeCasts(items: Array<N.Expression | undefined | null>) {\n      items.forEach(node => {\n        if (node?.type === \"TSTypeCastExpression\") {\n          this.raise(TSErrors.UnexpectedTypeAnnotation, {\n            at: node.typeAnnotation,\n          });\n        }\n      });\n    }\n\n    toReferencedList(\n      exprList: Array<N.Expression | undefined | null>,\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n      isInParens?: boolean,\n    ): Array<N.Expression | undefined | null> {\n      // Handles invalid scenarios like: `f(a:b)`, `(a:b);`, and `(a:b,c:d)`.\n      //\n      // Note that `f<T>(a:b)` goes through a different path and is handled\n      // in `parseSubscript` directly.\n      this.tsCheckForInvalidTypeCasts(exprList);\n      return exprList;\n    }\n\n    parseArrayLike(\n      close: TokenType,\n      canBePattern: boolean,\n      isTuple: boolean,\n      refExpressionErrors?: ExpressionErrors | null,\n    ): N.ArrayExpression | N.TupleExpression {\n      const node = super.parseArrayLike(\n        close,\n        canBePattern,\n        isTuple,\n        refExpressionErrors,\n      );\n\n      if (node.type === \"ArrayExpression\") {\n        this.tsCheckForInvalidTypeCasts(node.elements);\n      }\n\n      return node;\n    }\n\n    parseSubscript(\n      base: N.Expression,\n\n      startLoc: Position,\n      noCalls: boolean | undefined | null,\n      state: N.ParseSubscriptState,\n    ): N.Expression {\n      if (!this.hasPrecedingLineBreak() && this.match(tt.bang)) {\n        // When ! is consumed as a postfix operator (non-null assertion),\n        // disallow JSX tag forming after. e.g. When parsing `p! < n.p!`\n        // `<n.p` can not be a start of JSX tag\n        this.state.canStartJSXElement = false;\n        this.next();\n\n        const nonNullExpression =\n          this.startNodeAt<N.TsNonNullExpression>(startLoc);\n        nonNullExpression.expression = base;\n        return this.finishNode(nonNullExpression, \"TSNonNullExpression\");\n      }\n\n      let isOptionalCall = false;\n      if (\n        this.match(tt.questionDot) &&\n        this.lookaheadCharCode() === charCodes.lessThan\n      ) {\n        if (noCalls) {\n          state.stop = true;\n          return base;\n        }\n        state.optionalChainMember = isOptionalCall = true;\n        this.next();\n      }\n\n      // handles 'f<<T>'\n      if (this.match(tt.lt) || this.match(tt.bitShiftL)) {\n        let missingParenErrorLoc;\n        // tsTryParseAndCatch is expensive, so avoid if not necessary.\n        // There are number of things we are going to \"maybe\" parse, like type arguments on\n        // tagged template expressions. If any of them fail, walk it back and continue.\n        const result = this.tsTryParseAndCatch(() => {\n          if (!noCalls && this.atPossibleAsyncArrow(base)) {\n            // Almost certainly this is a generic async function `async <T>() => ...\n            // But it might be a call with a type argument `async<T>();`\n            const asyncArrowFn =\n              this.tsTryParseGenericAsyncArrowFunction(startLoc);\n            if (asyncArrowFn) {\n              return asyncArrowFn;\n            }\n          }\n\n          const typeArguments = this.tsParseTypeArgumentsInExpression();\n          if (!typeArguments) return;\n\n          if (isOptionalCall && !this.match(tt.parenL)) {\n            missingParenErrorLoc = this.state.curPosition();\n            return;\n          }\n\n          if (tokenIsTemplate(this.state.type)) {\n            const result = super.parseTaggedTemplateExpression(\n              base,\n\n              startLoc,\n              state,\n            );\n            result.typeParameters = typeArguments;\n            return result;\n          }\n\n          if (!noCalls && this.eat(tt.parenL)) {\n            const node = this.startNodeAt<\n              N.CallExpression | N.OptionalCallExpression\n            >(startLoc);\n            node.callee = base;\n            // possibleAsync always false here, because we would have handled it above.\n            // @ts-expect-error (won't be any undefined arguments)\n            node.arguments = this.parseCallExpressionArguments(\n              tt.parenR,\n              /* possibleAsync */ false,\n            );\n\n            // Handles invalid case: `f<T>(a:b)`\n            this.tsCheckForInvalidTypeCasts(node.arguments);\n\n            node.typeParameters = typeArguments;\n            if (state.optionalChainMember) {\n              (node as Undone<N.OptionalCallExpression>).optional =\n                isOptionalCall;\n            }\n\n            return this.finishCallExpression(node, state.optionalChainMember);\n          }\n\n          const tokenType = this.state.type;\n          if (\n            // a<b>>c is not (a<b>)>c, but a<(b>>c)\n            tokenType === tt.gt ||\n            // a<b>>>c is not (a<b>)>>c, but a<(b>>>c)\n            tokenType === tt.bitShiftR ||\n            // a<b>c is (a<b)>c\n            (tokenType !== tt.parenL &&\n              tokenCanStartExpression(tokenType) &&\n              !this.hasPrecedingLineBreak())\n          ) {\n            // Bail out.\n            return;\n          }\n\n          const node = this.startNodeAt<N.TsInstantiationExpression>(startLoc);\n          node.expression = base;\n          node.typeParameters = typeArguments;\n          return this.finishNode(node, \"TSInstantiationExpression\");\n        });\n\n        if (missingParenErrorLoc) {\n          this.unexpected(missingParenErrorLoc, tt.parenL);\n        }\n\n        if (result) {\n          if (\n            result.type === \"TSInstantiationExpression\" &&\n            (this.match(tt.dot) ||\n              (this.match(tt.questionDot) &&\n                this.lookaheadCharCode() !== charCodes.leftParenthesis))\n          ) {\n            this.raise(\n              TSErrors.InvalidPropertyAccessAfterInstantiationExpression,\n              { at: this.state.startLoc },\n            );\n          }\n          return result;\n        }\n      }\n\n      return super.parseSubscript(base, startLoc, noCalls, state);\n    }\n\n    parseNewCallee(node: N.NewExpression): void {\n      super.parseNewCallee(node);\n\n      const { callee } = node;\n      if (\n        callee.type === \"TSInstantiationExpression\" &&\n        !callee.extra?.parenthesized\n      ) {\n        node.typeParameters = callee.typeParameters;\n        node.callee = callee.expression;\n      }\n    }\n\n    parseExprOp(\n      left: N.Expression,\n      leftStartLoc: Position,\n      minPrec: number,\n    ): N.Expression {\n      let isSatisfies: boolean;\n      if (\n        tokenOperatorPrecedence(tt._in) > minPrec &&\n        !this.hasPrecedingLineBreak() &&\n        (this.isContextual(tt._as) ||\n          (isSatisfies = this.isContextual(tt._satisfies)))\n      ) {\n        const node = this.startNodeAt<\n          N.TsAsExpression | N.TsSatisfiesExpression\n        >(leftStartLoc);\n        node.expression = left;\n        node.typeAnnotation = this.tsInType(() => {\n          this.next(); // \"as\" or \"satisfies\"\n          if (this.match(tt._const)) {\n            if (isSatisfies) {\n              this.raise(Errors.UnexpectedKeyword, {\n                at: this.state.startLoc,\n                keyword: \"const\",\n              });\n            }\n            return this.tsParseTypeReference();\n          }\n\n          return this.tsParseType();\n        });\n        this.finishNode(\n          node,\n          isSatisfies ? \"TSSatisfiesExpression\" : \"TSAsExpression\",\n        );\n        // rescan `<`, `>` because they were scanned when this.state.inType was true\n        this.reScan_lt_gt();\n        return this.parseExprOp(\n          // @ts-expect-error todo(flow->ts)\n          node,\n          leftStartLoc,\n          minPrec,\n        );\n      }\n\n      return super.parseExprOp(left, leftStartLoc, minPrec);\n    }\n\n    checkReservedWord(\n      word: string,\n      startLoc: Position,\n      checkKeywords: boolean,\n      isBinding: boolean,\n    ): void {\n      // Strict mode words may be allowed as in `declare namespace N { const static: number; }`.\n      // And we have a type checker anyway, so don't bother having the parser do it.\n      if (!this.state.isAmbientContext) {\n        super.checkReservedWord(word, startLoc, checkKeywords, isBinding);\n      }\n    }\n\n    checkImportReflection(node: Undone<N.ImportDeclaration>) {\n      super.checkImportReflection(node);\n      if (node.module && node.importKind !== \"value\") {\n        this.raise(TSErrors.ImportReflectionHasImportType, {\n          at: node.specifiers[0].loc.start,\n        });\n      }\n    }\n\n    /*\n    Don't bother doing this check in TypeScript code because:\n    1. We may have a nested export statement with the same name:\n      export const x = 0;\n      export namespace N {\n        export const x = 1;\n      }\n    2. We have a type checker to warn us about this sort of thing.\n    */\n    checkDuplicateExports() {}\n\n    isPotentialImportPhase(isExport: boolean): boolean {\n      if (super.isPotentialImportPhase(isExport)) return true;\n      if (this.isContextual(tt._type)) {\n        const ch = this.lookaheadCharCode();\n        return isExport\n          ? ch === charCodes.leftCurlyBrace || ch === charCodes.asterisk\n          : ch !== charCodes.equalsTo;\n      }\n      return !isExport && this.isContextual(tt._typeof);\n    }\n\n    applyImportPhase(\n      node: Undone<N.ImportDeclaration | N.ExportNamedDeclaration>,\n      isExport: boolean,\n      phase: string | null,\n      loc?: Position,\n    ): void {\n      super.applyImportPhase(node, isExport, phase, loc);\n      if (isExport) {\n        (node as N.ExportNamedDeclaration).exportKind =\n          phase === \"type\" ? \"type\" : \"value\";\n      } else {\n        (node as N.ImportDeclaration).importKind =\n          phase === \"type\" || phase === \"typeof\" ? phase : \"value\";\n      }\n    }\n\n    parseImport(\n      node: Undone<N.ImportDeclaration | N.TsImportEqualsDeclaration>,\n    ): N.AnyImport {\n      if (this.match(tt.string)) {\n        node.importKind = \"value\";\n        return super.parseImport(node as Undone<N.ImportDeclaration>);\n      }\n\n      let importNode;\n      if (\n        tokenIsIdentifier(this.state.type) &&\n        this.lookaheadCharCode() === charCodes.equalsTo\n      ) {\n        node.importKind = \"value\";\n        return this.tsParseImportEqualsDeclaration(\n          node as Undone<N.TsImportEqualsDeclaration>,\n        );\n      } else if (this.isContextual(tt._type)) {\n        const maybeDefaultIdentifier = this.parseMaybeImportPhase(\n          node as Undone<N.ImportDeclaration>,\n          /* isExport */ false,\n        );\n        if (this.lookaheadCharCode() === charCodes.equalsTo) {\n          return this.tsParseImportEqualsDeclaration(\n            node as Undone<N.TsImportEqualsDeclaration>,\n            maybeDefaultIdentifier,\n          );\n        } else {\n          importNode = super.parseImportSpecifiersAndAfter(\n            node as Undone<N.ImportDeclaration>,\n            maybeDefaultIdentifier,\n          );\n        }\n      } else {\n        importNode = super.parseImport(node as Undone<N.ImportDeclaration>);\n      }\n\n      // `import type` can only be used on imports with named imports or with a\n      // default import - but not both\n      if (\n        importNode.importKind === \"type\" &&\n        // @ts-expect-error refine typings\n        importNode.specifiers.length > 1 &&\n        // @ts-expect-error refine typings\n        importNode.specifiers[0].type === \"ImportDefaultSpecifier\"\n      ) {\n        this.raise(TSErrors.TypeImportCannotSpecifyDefaultAndNamed, {\n          at: importNode,\n        });\n      }\n\n      return importNode;\n    }\n\n    parseExport(\n      node: Undone<N.Node>,\n      decorators: N.Decorator[] | null,\n    ): N.AnyExport {\n      if (this.match(tt._import)) {\n        // `export import A = B;`\n        this.next(); // eat `tt._import`\n        let maybeDefaultIdentifier: N.Identifier | null = null;\n        if (\n          this.isContextual(tt._type) &&\n          // We pass false here, because we are parsing an `import ... =`\n          this.isPotentialImportPhase(/* isExport */ false)\n        ) {\n          maybeDefaultIdentifier = this.parseMaybeImportPhase(\n            node as Undone<N.TsImportEqualsDeclaration>,\n            /* isExport */ false,\n          );\n        } else {\n          node.importKind = \"value\";\n        }\n        return this.tsParseImportEqualsDeclaration(\n          node as Undone<N.TsImportEqualsDeclaration>,\n          maybeDefaultIdentifier,\n          /* isExport */ true,\n        );\n      } else if (this.eat(tt.eq)) {\n        // `export = x;`\n        const assign = node as Undone<N.TsExportAssignment>;\n        assign.expression = super.parseExpression();\n        this.semicolon();\n        this.sawUnambiguousESM = true;\n        return this.finishNode(assign, \"TSExportAssignment\");\n      } else if (this.eatContextual(tt._as)) {\n        // `export as namespace A;`\n        const decl = node as Undone<N.TsNamespaceExportDeclaration>;\n        // See `parseNamespaceExportDeclaration` in TypeScript's own parser\n        this.expectContextual(tt._namespace);\n        decl.id = this.parseIdentifier();\n        this.semicolon();\n        return this.finishNode(decl, \"TSNamespaceExportDeclaration\");\n      } else {\n        return super.parseExport(\n          node as Undone<N.ExportAllDeclaration | N.ExportDefaultDeclaration>,\n          decorators,\n        );\n      }\n    }\n\n    isAbstractClass(): boolean {\n      return (\n        this.isContextual(tt._abstract) && this.lookahead().type === tt._class\n      );\n    }\n\n    parseExportDefaultExpression(): N.Expression | N.Declaration {\n      if (this.isAbstractClass()) {\n        const cls = this.startNode<N.Class>();\n        this.next(); // Skip \"abstract\"\n        cls.abstract = true;\n        return this.parseClass(cls, true, true);\n      }\n\n      // export default interface allowed in:\n      // https://github.com/Microsoft/TypeScript/pull/16040\n      if (this.match(tt._interface)) {\n        const result = this.tsParseInterfaceDeclaration(\n          this.startNode<N.TsInterfaceDeclaration>(),\n        );\n        if (result) return result;\n      }\n\n      return super.parseExportDefaultExpression();\n    }\n\n    parseVarStatement(\n      node: N.VariableDeclaration,\n      kind: \"var\" | \"let\" | \"const\" | \"using\",\n      allowMissingInitializer: boolean = false,\n    ) {\n      const { isAmbientContext } = this.state;\n      const declaration = super.parseVarStatement(\n        node,\n        kind,\n        allowMissingInitializer || isAmbientContext,\n      );\n\n      if (!isAmbientContext) return declaration;\n\n      for (const { id, init } of declaration.declarations) {\n        // Empty initializer is the easy case that we want.\n        if (!init) continue;\n\n        // var and let aren't ever allowed initializers.\n        if (kind !== \"const\" || !!id.typeAnnotation) {\n          this.raise(TSErrors.InitializerNotAllowedInAmbientContext, {\n            at: init,\n          });\n        } else if (\n          !isValidAmbientConstInitializer(init, this.hasPlugin(\"estree\"))\n        ) {\n          this.raise(\n            TSErrors.ConstInitiailizerMustBeStringOrNumericLiteralOrLiteralEnumReference,\n            { at: init },\n          );\n        }\n      }\n\n      return declaration;\n    }\n\n    parseStatementContent(\n      flags: ParseStatementFlag,\n      decorators?: N.Decorator[] | null,\n    ): N.Statement {\n      if (this.match(tt._const) && this.isLookaheadContextual(\"enum\")) {\n        const node = this.startNode<N.TsEnumDeclaration>();\n        this.expect(tt._const); // eat 'const'\n        return this.tsParseEnumDeclaration(node, { const: true });\n      }\n\n      if (this.isContextual(tt._enum)) {\n        return this.tsParseEnumDeclaration(\n          this.startNode<N.TsEnumDeclaration>(),\n        );\n      }\n\n      if (this.isContextual(tt._interface)) {\n        const result = this.tsParseInterfaceDeclaration(this.startNode());\n        if (result) return result;\n      }\n\n      return super.parseStatementContent(flags, decorators);\n    }\n\n    parseAccessModifier(): N.Accessibility | undefined | null {\n      return this.tsParseModifier([\"public\", \"protected\", \"private\"]);\n    }\n\n    tsHasSomeModifiers(member: any, modifiers: readonly TsModifier[]): boolean {\n      return modifiers.some(modifier => {\n        if (tsIsAccessModifier(modifier)) {\n          return member.accessibility === modifier;\n        }\n        return !!member[modifier];\n      });\n    }\n\n    tsIsStartOfStaticBlocks() {\n      return (\n        this.isContextual(tt._static) &&\n        this.lookaheadCharCode() === charCodes.leftCurlyBrace\n      );\n    }\n\n    parseClassMember(\n      classBody: N.ClassBody,\n      member: any,\n      state: N.ParseClassMemberState,\n    ): void {\n      const modifiers = [\n        \"declare\",\n        \"private\",\n        \"public\",\n        \"protected\",\n        \"override\",\n        \"abstract\",\n        \"readonly\",\n        \"static\",\n      ] as const;\n      this.tsParseModifiers(\n        {\n          allowedModifiers: modifiers,\n          disallowedModifiers: [\"in\", \"out\"],\n          stopOnStartOfClassStaticBlock: true,\n          errorTemplate: TSErrors.InvalidModifierOnTypeParameterPositions,\n        },\n        member,\n      );\n\n      const callParseClassMemberWithIsStatic = () => {\n        if (this.tsIsStartOfStaticBlocks()) {\n          this.next(); // eat \"static\"\n          this.next(); // eat \"{\"\n          if (this.tsHasSomeModifiers(member, modifiers)) {\n            this.raise(TSErrors.StaticBlockCannotHaveModifier, {\n              at: this.state.curPosition(),\n            });\n          }\n          super.parseClassStaticBlock(classBody, member as N.StaticBlock);\n        } else {\n          this.parseClassMemberWithIsStatic(\n            classBody,\n            member,\n            state,\n            !!member.static,\n          );\n        }\n      };\n      if (member.declare) {\n        this.tsInAmbientContext(callParseClassMemberWithIsStatic);\n      } else {\n        callParseClassMemberWithIsStatic();\n      }\n    }\n\n    parseClassMemberWithIsStatic(\n      classBody: N.ClassBody,\n      member: Undone<N.ClassMember | N.TsIndexSignature>,\n      state: N.ParseClassMemberState,\n      isStatic: boolean,\n    ): void {\n      const idx = this.tsTryParseIndexSignature(\n        member as Undone<N.TsIndexSignature>,\n      );\n      if (idx) {\n        classBody.body.push(idx);\n\n        if ((member as any).abstract) {\n          this.raise(TSErrors.IndexSignatureHasAbstract, { at: member });\n        }\n        if ((member as any).accessibility) {\n          this.raise(TSErrors.IndexSignatureHasAccessibility, {\n            at: member,\n            modifier: (member as any).accessibility,\n          });\n        }\n        if ((member as any).declare) {\n          this.raise(TSErrors.IndexSignatureHasDeclare, { at: member });\n        }\n        if ((member as any).override) {\n          this.raise(TSErrors.IndexSignatureHasOverride, { at: member });\n        }\n\n        return;\n      }\n\n      if (!this.state.inAbstractClass && (member as any).abstract) {\n        this.raise(TSErrors.NonAbstractClassHasAbstractMethod, {\n          at: member,\n        });\n      }\n\n      if ((member as any).override) {\n        if (!state.hadSuperClass) {\n          this.raise(TSErrors.OverrideNotInSubClass, { at: member });\n        }\n      }\n\n      /*:: invariant(member.type !== \"TSIndexSignature\") */\n\n      super.parseClassMemberWithIsStatic(\n        classBody,\n        member as Undone<N.ClassMember>,\n        state,\n        isStatic,\n      );\n    }\n\n    parsePostMemberNameModifiers(\n      methodOrProp: N.ClassMethod | N.ClassProperty | N.ClassPrivateProperty,\n    ): void {\n      const optional = this.eat(tt.question);\n      if (optional) methodOrProp.optional = true;\n\n      if ((methodOrProp as any).readonly && this.match(tt.parenL)) {\n        this.raise(TSErrors.ClassMethodHasReadonly, { at: methodOrProp });\n      }\n\n      if ((methodOrProp as any).declare && this.match(tt.parenL)) {\n        this.raise(TSErrors.ClassMethodHasDeclare, { at: methodOrProp });\n      }\n    }\n\n    // Note: The reason we do this in `parseExpressionStatement` and not `parseStatement`\n    // is that e.g. `type()` is valid JS, so we must try parsing that first.\n    // If it's really a type, we will parse `type` as the statement, and can correct it here\n    // by parsing the rest.\n    // @ts-expect-error plugin overrides interfaces\n    parseExpressionStatement(\n      node: Undone<N.ExpressionStatement>,\n      expr: N.Expression,\n      decorators: N.Decorator[] | null,\n    ): N.Statement {\n      const decl =\n        expr.type === \"Identifier\"\n          ? // @ts-expect-error refine typings\n            this.tsParseExpressionStatement(node, expr, decorators)\n          : undefined;\n      return decl || super.parseExpressionStatement(node, expr, decorators);\n    }\n\n    // export type\n    // Should be true for anything parsed by `tsTryParseExportDeclaration`.\n    shouldParseExportDeclaration(): boolean {\n      if (this.tsIsDeclarationStart()) return true;\n      return super.shouldParseExportDeclaration();\n    }\n\n    // An apparent conditional expression could actually be an optional parameter in an arrow function.\n    parseConditional(\n      expr: N.Expression,\n\n      startLoc: Position,\n      refExpressionErrors?: ExpressionErrors | null,\n    ): N.Expression {\n      // only do the expensive clone if there is a question mark\n      // and if we come from inside parens\n      if (!this.state.maybeInArrowParameters || !this.match(tt.question)) {\n        return super.parseConditional(\n          expr,\n\n          startLoc,\n          refExpressionErrors,\n        );\n      }\n\n      const result = this.tryParse(() =>\n        super.parseConditional(expr, startLoc),\n      );\n\n      if (!result.node) {\n        if (result.error) {\n          /*:: invariant(refExpressionErrors != null) */\n          super.setOptionalParametersError(refExpressionErrors, result.error);\n        }\n\n        return expr;\n      }\n      if (result.error) this.state = result.failState;\n      return result.node;\n    }\n\n    // Note: These \"type casts\" are *not* valid TS expressions.\n    // But we parse them here and change them when completing the arrow function.\n    parseParenItem(\n      node: N.Expression,\n\n      startLoc: Position,\n    ): N.Expression {\n      node = super.parseParenItem(node, startLoc);\n      if (this.eat(tt.question)) {\n        node.optional = true;\n        // Include questionmark in location of node\n        // Don't use this.finishNode() as otherwise we might process comments twice and\n        // include already consumed parens\n        this.resetEndLocation(node);\n      }\n\n      if (this.match(tt.colon)) {\n        const typeCastNode = this.startNodeAt<N.TsTypeCastExpression>(startLoc);\n        typeCastNode.expression = node;\n        typeCastNode.typeAnnotation = this.tsParseTypeAnnotation();\n\n        return this.finishNode(typeCastNode, \"TSTypeCastExpression\");\n      }\n\n      return node;\n    }\n\n    parseExportDeclaration(\n      node: N.ExportNamedDeclaration,\n    ): N.Declaration | undefined | null {\n      if (!this.state.isAmbientContext && this.isContextual(tt._declare)) {\n        return this.tsInAmbientContext(() => this.parseExportDeclaration(node));\n      }\n\n      // Store original location\n      const startLoc = this.state.startLoc;\n\n      const isDeclare = this.eatContextual(tt._declare);\n\n      if (\n        isDeclare &&\n        (this.isContextual(tt._declare) || !this.shouldParseExportDeclaration())\n      ) {\n        throw this.raise(TSErrors.ExpectedAmbientAfterExportDeclare, {\n          at: this.state.startLoc,\n        });\n      }\n\n      const isIdentifier = tokenIsIdentifier(this.state.type);\n      const declaration: N.Declaration | undefined | null =\n        (isIdentifier && this.tsTryParseExportDeclaration()) ||\n        super.parseExportDeclaration(node);\n\n      if (!declaration) return null;\n\n      if (\n        declaration.type === \"TSInterfaceDeclaration\" ||\n        declaration.type === \"TSTypeAliasDeclaration\" ||\n        isDeclare\n      ) {\n        node.exportKind = \"type\";\n      }\n\n      if (isDeclare) {\n        // Reset location to include `declare` in range\n        this.resetStartLocation(declaration, startLoc);\n\n        declaration.declare = true;\n      }\n\n      return declaration;\n    }\n\n    parseClassId(\n      node: N.Class,\n      isStatement: boolean,\n      optionalId?: boolean | null,\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n      bindingType?: BindingTypes,\n    ): void {\n      if ((!isStatement || optionalId) && this.isContextual(tt._implements)) {\n        return;\n      }\n\n      super.parseClassId(\n        node,\n        isStatement,\n        optionalId,\n        (node as any).declare ? BIND_TS_AMBIENT : BIND_CLASS,\n      );\n      const typeParameters = this.tsTryParseTypeParameters(\n        this.tsParseInOutConstModifiers,\n      );\n      if (typeParameters) node.typeParameters = typeParameters;\n    }\n\n    parseClassPropertyAnnotation(\n      node: N.ClassProperty | N.ClassPrivateProperty | N.ClassAccessorProperty,\n    ): void {\n      if (!node.optional) {\n        if (this.eat(tt.bang)) {\n          node.definite = true;\n        } else if (this.eat(tt.question)) {\n          node.optional = true;\n        }\n      }\n\n      const type = this.tsTryParseTypeAnnotation();\n      if (type) node.typeAnnotation = type;\n    }\n\n    parseClassProperty(node: N.ClassProperty): N.ClassProperty {\n      this.parseClassPropertyAnnotation(node);\n\n      if (\n        this.state.isAmbientContext &&\n        !(node.readonly && !node.typeAnnotation) &&\n        this.match(tt.eq)\n      ) {\n        this.raise(TSErrors.DeclareClassFieldHasInitializer, {\n          at: this.state.startLoc,\n        });\n      }\n      if (node.abstract && this.match(tt.eq)) {\n        const { key } = node;\n        this.raise(TSErrors.AbstractPropertyHasInitializer, {\n          at: this.state.startLoc,\n          propertyName:\n            key.type === \"Identifier\" && !node.computed\n              ? key.name\n              : `[${this.input.slice(key.start, key.end)}]`,\n        });\n      }\n\n      return super.parseClassProperty(node);\n    }\n\n    parseClassPrivateProperty(\n      node: N.ClassPrivateProperty,\n    ): N.ClassPrivateProperty {\n      // @ts-expect-error abstract may not index node\n      if (node.abstract) {\n        this.raise(TSErrors.PrivateElementHasAbstract, { at: node });\n      }\n\n      // @ts-expect-error accessibility may not index node\n      if (node.accessibility) {\n        this.raise(TSErrors.PrivateElementHasAccessibility, {\n          at: node,\n          // @ts-expect-error refine typings\n          modifier: node.accessibility,\n        });\n      }\n\n      this.parseClassPropertyAnnotation(node);\n      return super.parseClassPrivateProperty(node);\n    }\n\n    parseClassAccessorProperty(\n      node: N.ClassAccessorProperty,\n    ): N.ClassAccessorProperty {\n      this.parseClassPropertyAnnotation(node);\n      if (node.optional) {\n        this.raise(TSErrors.AccessorCannotBeOptional, { at: node });\n      }\n      return super.parseClassAccessorProperty(node);\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      const typeParameters = this.tsTryParseTypeParameters(\n        this.tsParseConstModifier,\n      );\n      if (typeParameters && isConstructor) {\n        this.raise(TSErrors.ConstructorHasTypeParameters, {\n          at: typeParameters,\n        });\n      }\n\n      // @ts-expect-error declare does not exist in ClassMethod\n      const { declare = false, kind } = method;\n\n      if (declare && (kind === \"get\" || kind === \"set\")) {\n        this.raise(TSErrors.DeclareAccessor, { at: method, kind });\n      }\n      if (typeParameters) method.typeParameters = typeParameters;\n      super.pushClassMethod(\n        classBody,\n        method,\n        isGenerator,\n        isAsync,\n        isConstructor,\n        allowsDirectSuper,\n      );\n    }\n\n    pushClassPrivateMethod(\n      classBody: N.ClassBody,\n      method: N.ClassPrivateMethod,\n      isGenerator: boolean,\n      isAsync: boolean,\n    ): void {\n      const typeParameters = this.tsTryParseTypeParameters(\n        this.tsParseConstModifier,\n      );\n      if (typeParameters) method.typeParameters = typeParameters;\n      super.pushClassPrivateMethod(classBody, method, isGenerator, isAsync);\n    }\n\n    declareClassPrivateMethodInScope(\n      node: N.ClassPrivateMethod | N.EstreeMethodDefinition | N.TSDeclareMethod,\n      kind: number,\n    ) {\n      if (node.type === \"TSDeclareMethod\") return;\n      // This happens when using the \"estree\" plugin.\n      if (node.type === \"MethodDefinition\" && !node.value.body) return;\n\n      super.declareClassPrivateMethodInScope(node, kind);\n    }\n\n    parseClassSuper(node: N.Class): void {\n      super.parseClassSuper(node);\n      // handle `extends f<<T>\n      if (node.superClass && (this.match(tt.lt) || this.match(tt.bitShiftL))) {\n        // @ts-expect-error refine typings\n        node.superTypeParameters = this.tsParseTypeArgumentsInExpression();\n      }\n      if (this.eatContextual(tt._implements)) {\n        node.implements = this.tsParseHeritageClause(\"implements\");\n      }\n    }\n\n    parseObjPropValue(\n      prop: Undone<N.ObjectMethod | N.ObjectProperty>,\n      startLoc: Position | undefined | null,\n      isGenerator: boolean,\n      isAsync: boolean,\n      isPattern: boolean,\n      isAccessor: boolean,\n      refExpressionErrors?: ExpressionErrors | null,\n    ) {\n      const typeParameters = this.tsTryParseTypeParameters(\n        this.tsParseConstModifier,\n      );\n      if (typeParameters) prop.typeParameters = typeParameters;\n\n      return super.parseObjPropValue(\n        prop,\n\n        startLoc,\n        isGenerator,\n        isAsync,\n        isPattern,\n        isAccessor,\n        refExpressionErrors,\n      );\n    }\n\n    parseFunctionParams(node: N.Function, isConstructor: boolean): void {\n      const typeParameters = this.tsTryParseTypeParameters(\n        this.tsParseConstModifier,\n      );\n      if (typeParameters) node.typeParameters = typeParameters;\n      super.parseFunctionParams(node, isConstructor);\n    }\n\n    // `let x: number;`\n    parseVarId(\n      decl: N.VariableDeclarator,\n      kind: \"var\" | \"let\" | \"const\" | \"using\",\n    ): void {\n      super.parseVarId(decl, kind);\n      if (\n        decl.id.type === \"Identifier\" &&\n        !this.hasPrecedingLineBreak() &&\n        this.eat(tt.bang)\n      ) {\n        decl.definite = true;\n      }\n\n      const type = this.tsTryParseTypeAnnotation();\n      if (type) {\n        decl.id.typeAnnotation = type;\n        this.resetEndLocation(decl.id); // set end position to end of type\n      }\n    }\n\n    // parse the return type of an async arrow function - let foo = (async (): number => {});\n    parseAsyncArrowFromCallExpression(\n      node: N.ArrowFunctionExpression,\n      call: N.CallExpression,\n    ): N.ArrowFunctionExpression {\n      if (this.match(tt.colon)) {\n        node.returnType = this.tsParseTypeAnnotation();\n      }\n      return super.parseAsyncArrowFromCallExpression(node, call);\n    }\n\n    parseMaybeAssign(\n      refExpressionErrors?: ExpressionErrors | null,\n      afterLeftParse?: Function,\n    ): N.Expression {\n      // Note: When the JSX plugin is on, type assertions (`<T> x`) aren't valid syntax.\n\n      let state: State | undefined | null;\n      let jsx;\n      let typeCast;\n\n      if (\n        this.hasPlugin(\"jsx\") &&\n        (this.match(tt.jsxTagStart) || this.match(tt.lt))\n      ) {\n        // Prefer to parse JSX if possible. But may be an arrow fn.\n        state = this.state.clone();\n\n        jsx = this.tryParse(\n          () => super.parseMaybeAssign(refExpressionErrors, afterLeftParse),\n          state,\n        );\n\n        /*:: invariant(!jsx.aborted) */\n        /*:: invariant(jsx.node != null) */\n        if (!jsx.error) return jsx.node;\n\n        // Remove `tc.j_expr` or `tc.j_oTag` from context added\n        // by parsing `jsxTagStart` to stop the JSX plugin from\n        // messing with the tokens\n        const { context } = this.state;\n        const currentContext = context[context.length - 1];\n        if (currentContext === tc.j_oTag || currentContext === tc.j_expr) {\n          context.pop();\n        }\n      }\n\n      if (!jsx?.error && !this.match(tt.lt)) {\n        return super.parseMaybeAssign(refExpressionErrors, afterLeftParse);\n      }\n\n      // Either way, we're looking at a '<': tt.jsxTagStart or relational.\n\n      // If the state was cloned in the JSX parsing branch above but there\n      // have been any error in the tryParse call, this.state is set to state\n      // so we still need to clone it.\n      if (!state || state === this.state) state = this.state.clone();\n\n      let typeParameters: N.TsTypeParameterDeclaration | undefined | null;\n      const arrow = this.tryParse(abort => {\n        // This is similar to TypeScript's `tryParseParenthesizedArrowFunctionExpression`.\n        typeParameters = this.tsParseTypeParameters(this.tsParseConstModifier);\n        const expr = super.parseMaybeAssign(\n          refExpressionErrors,\n          afterLeftParse,\n        );\n\n        if (\n          expr.type !== \"ArrowFunctionExpression\" ||\n          expr.extra?.parenthesized\n        ) {\n          abort();\n        }\n\n        // Correct TypeScript code should have at least 1 type parameter, but don't crash on bad code.\n        if (typeParameters?.params.length !== 0) {\n          this.resetStartLocationFromNode(expr, typeParameters);\n        }\n        expr.typeParameters = typeParameters;\n\n        if (process.env.BABEL_8_BREAKING) {\n          if (\n            this.hasPlugin(\"jsx\") &&\n            expr.typeParameters.params.length === 1 &&\n            !expr.typeParameters.extra?.trailingComma\n          ) {\n            // report error if single type parameter used without trailing comma.\n            const parameter = expr.typeParameters.params[0];\n            if (!parameter.constraint) {\n              // A single type parameter must either have constraints\n              // or a trailing comma, otherwise it's ambiguous with JSX.\n              this.raise(TSErrors.SingleTypeParameterWithoutTrailingComma, {\n                at: createPositionWithColumnOffset(parameter.loc.end, 1),\n                typeParameterName: parameter.name.name,\n              });\n            }\n          }\n        }\n\n        return expr;\n      }, state);\n\n      /*:: invariant(arrow.node != null) */\n      if (!arrow.error && !arrow.aborted) {\n        // This error is reported outside of the this.tryParse call so that\n        // in case of <T>(x) => 2, we don't consider <T>(x) as a type assertion\n        // because of this error.\n        if (typeParameters) this.reportReservedArrowTypeParam(typeParameters);\n        // @ts-expect-error refine typings\n        return arrow.node;\n      }\n\n      if (!jsx) {\n        // Try parsing a type cast instead of an arrow function.\n        // This will never happen outside of JSX.\n        // (Because in JSX the '<' should be a jsxTagStart and not a relational.\n        assert(!this.hasPlugin(\"jsx\"));\n\n        // This will start with a type assertion (via parseMaybeUnary).\n        // But don't directly call `this.tsParseTypeAssertion` because we want to handle any binary after it.\n        typeCast = this.tryParse(\n          () => super.parseMaybeAssign(refExpressionErrors, afterLeftParse),\n          state,\n        );\n        /*:: invariant(!typeCast.aborted) */\n        /*:: invariant(typeCast.node != null) */\n        if (!typeCast.error) return typeCast.node;\n      }\n\n      if (jsx?.node) {\n        /*:: invariant(jsx.failState) */\n        this.state = jsx.failState;\n        return jsx.node;\n      }\n\n      if (arrow.node) {\n        /*:: invariant(arrow.failState) */\n        this.state = arrow.failState;\n        if (typeParameters) this.reportReservedArrowTypeParam(typeParameters);\n        // @ts-expect-error refine typings\n        return arrow.node;\n      }\n\n      if (typeCast?.node) {\n        /*:: invariant(typeCast.failState) */\n        this.state = typeCast.failState;\n        return typeCast.node;\n      }\n\n      throw jsx?.error || arrow.error || typeCast?.error;\n    }\n\n    reportReservedArrowTypeParam(node: any) {\n      if (\n        node.params.length === 1 &&\n        !node.params[0].constraint &&\n        !node.extra?.trailingComma &&\n        this.getPluginOption(\"typescript\", \"disallowAmbiguousJSXLike\")\n      ) {\n        this.raise(TSErrors.ReservedArrowTypeParam, { at: node });\n      }\n    }\n\n    // Handle type assertions\n    parseMaybeUnary(\n      refExpressionErrors?: ExpressionErrors | null,\n      sawUnary?: boolean,\n    ): N.Expression {\n      if (!this.hasPlugin(\"jsx\") && this.match(tt.lt)) {\n        return this.tsParseTypeAssertion();\n      }\n      return super.parseMaybeUnary(refExpressionErrors, sawUnary);\n    }\n\n    parseArrow(\n      node: Undone<N.ArrowFunctionExpression>,\n    ): Undone<N.ArrowFunctionExpression> | undefined | null {\n      if (this.match(tt.colon)) {\n        // This is different from how the TS parser does it.\n        // TS uses lookahead. The Babel Parser parses it as a parenthesized expression and converts.\n\n        const result = this.tryParse(abort => {\n          const returnType = this.tsParseTypeOrTypePredicateAnnotation(\n            tt.colon,\n          );\n          if (this.canInsertSemicolon() || !this.match(tt.arrow)) abort();\n          return returnType;\n        });\n\n        if (result.aborted) return;\n\n        if (!result.thrown) {\n          if (result.error) this.state = result.failState;\n          // @ts-expect-error refine typings\n          node.returnType = result.node;\n        }\n      }\n\n      return super.parseArrow(node);\n    }\n\n    // Allow type annotations inside of a parameter list.\n    parseAssignableListItemTypes(\n      param: N.Pattern,\n      flags: ParseBindingListFlags,\n    ) {\n      if (!(flags & ParseBindingListFlags.IS_FUNCTION_PARAMS)) return param;\n\n      if (this.eat(tt.question)) {\n        (param as any as N.Identifier).optional = true;\n      }\n      const type = this.tsTryParseTypeAnnotation();\n      if (type) param.typeAnnotation = type;\n      this.resetEndLocation(param);\n\n      return param;\n    }\n\n    isAssignable(node: N.Node, isBinding?: boolean): boolean {\n      switch (node.type) {\n        case \"TSTypeCastExpression\":\n          return this.isAssignable(node.expression, isBinding);\n        case \"TSParameterProperty\":\n          return true;\n        default:\n          return super.isAssignable(node, isBinding);\n      }\n    }\n\n    toAssignable(node: N.Node, isLHS: boolean = false): void {\n      switch (node.type) {\n        case \"ParenthesizedExpression\":\n          this.toAssignableParenthesizedExpression(node, isLHS);\n          break;\n        case \"TSAsExpression\":\n        case \"TSSatisfiesExpression\":\n        case \"TSNonNullExpression\":\n        case \"TSTypeAssertion\":\n          if (isLHS) {\n            this.expressionScope.recordArrowParameterBindingError(\n              TSErrors.UnexpectedTypeCastInParameter,\n              { at: node },\n            );\n          } else {\n            this.raise(TSErrors.UnexpectedTypeCastInParameter, { at: node });\n          }\n          this.toAssignable(node.expression, isLHS);\n          break;\n        case \"AssignmentExpression\":\n          if (!isLHS && node.left.type === \"TSTypeCastExpression\") {\n            node.left = this.typeCastToParameter(node.left);\n          }\n        /* fall through */\n        default:\n          super.toAssignable(node, isLHS);\n      }\n    }\n\n    toAssignableParenthesizedExpression(node: N.Node, isLHS: boolean): void {\n      switch (node.expression.type) {\n        case \"TSAsExpression\":\n        case \"TSSatisfiesExpression\":\n        case \"TSNonNullExpression\":\n        case \"TSTypeAssertion\":\n        case \"ParenthesizedExpression\":\n          this.toAssignable(node.expression, isLHS);\n          break;\n        default:\n          super.toAssignable(node, isLHS);\n      }\n    }\n\n    checkToRestConversion(node: N.Node, allowPattern: boolean): void {\n      switch (node.type) {\n        case \"TSAsExpression\":\n        case \"TSSatisfiesExpression\":\n        case \"TSTypeAssertion\":\n        case \"TSNonNullExpression\":\n          this.checkToRestConversion(node.expression, false);\n          break;\n        default:\n          super.checkToRestConversion(node, allowPattern);\n      }\n    }\n\n    // @ts-expect-error plugin overrides interfaces\n    isValidLVal(\n      type:\n        | \"TSTypeCastExpression\"\n        | \"TSParameterProperty\"\n        | \"TSNonNullExpression\"\n        | \"TSAsExpression\"\n        | \"TSSatisfiesExpression\"\n        | \"TSTypeAssertion\",\n      isUnparenthesizedInAssign: boolean,\n      binding: BindingTypes,\n    ) {\n      return (\n        getOwn(\n          {\n            // Allow \"typecasts\" to appear on the left of assignment expressions,\n            // because it may be in an arrow function.\n            // e.g. `const f = (foo: number = 0) => foo;`\n            TSTypeCastExpression: true,\n            TSParameterProperty: \"parameter\",\n            TSNonNullExpression: \"expression\",\n            TSAsExpression: (binding !== BIND_NONE ||\n              !isUnparenthesizedInAssign) && [\"expression\", true],\n            TSSatisfiesExpression: (binding !== BIND_NONE ||\n              !isUnparenthesizedInAssign) && [\"expression\", true],\n            TSTypeAssertion: (binding !== BIND_NONE ||\n              !isUnparenthesizedInAssign) && [\"expression\", true],\n          },\n          type,\n        ) || super.isValidLVal(type, isUnparenthesizedInAssign, binding)\n      );\n    }\n\n    parseBindingAtom(): N.Pattern {\n      if (this.state.type === tt._this) {\n        return this.parseIdentifier(/* liberal */ true);\n      }\n      return super.parseBindingAtom();\n    }\n\n    parseMaybeDecoratorArguments(expr: N.Expression): N.Expression {\n      // handles `@f<<T>`\n      if (this.match(tt.lt) || this.match(tt.bitShiftL)) {\n        const typeArguments = this.tsParseTypeArgumentsInExpression();\n\n        if (this.match(tt.parenL)) {\n          const call = super.parseMaybeDecoratorArguments(expr);\n          call.typeParameters = typeArguments;\n          return call;\n        }\n\n        this.unexpected(null, tt.parenL);\n      }\n\n      return super.parseMaybeDecoratorArguments(expr);\n    }\n\n    checkCommaAfterRest(\n      close: (typeof charCodes)[keyof typeof charCodes],\n    ): boolean {\n      if (\n        this.state.isAmbientContext &&\n        this.match(tt.comma) &&\n        this.lookaheadCharCode() === close\n      ) {\n        this.next();\n        return false;\n      }\n      return super.checkCommaAfterRest(close);\n    }\n\n    // === === === === === === === === === === === === === === === ===\n    // Note: All below methods are duplicates of something in flow.js.\n    // Not sure what the best way to combine these is.\n    // === === === === === === === === === === === === === === === ===\n\n    isClassMethod(): boolean {\n      return this.match(tt.lt) || super.isClassMethod();\n    }\n\n    isClassProperty(): boolean {\n      return (\n        this.match(tt.bang) || this.match(tt.colon) || super.isClassProperty()\n      );\n    }\n\n    parseMaybeDefault(\n      startLoc?: Position | null,\n      left?: Pattern | null,\n    ): N.Pattern {\n      const node = super.parseMaybeDefault(startLoc, left);\n\n      if (\n        node.type === \"AssignmentPattern\" &&\n        node.typeAnnotation &&\n        node.right.start < node.typeAnnotation.start\n      ) {\n        this.raise(TSErrors.TypeAnnotationAfterAssign, {\n          at: node.typeAnnotation,\n        });\n      }\n\n      return node;\n    }\n\n    // ensure that inside types, we bypass the jsx parser plugin\n    getTokenFromCode(code: number): void {\n      if (this.state.inType) {\n        if (code === charCodes.greaterThan) {\n          this.finishOp(tt.gt, 1);\n          return;\n        }\n        if (code === charCodes.lessThan) {\n          this.finishOp(tt.lt, 1);\n          return;\n        }\n      }\n      super.getTokenFromCode(code);\n    }\n\n    // used after we have finished parsing types\n    reScan_lt_gt() {\n      const { type } = this.state;\n      if (type === tt.lt) {\n        this.state.pos -= 1;\n        this.readToken_lt();\n      } else if (type === tt.gt) {\n        this.state.pos -= 1;\n        this.readToken_gt();\n      }\n    }\n\n    reScan_lt() {\n      const { type } = this.state;\n      if (type === tt.bitShiftL) {\n        this.state.pos -= 2;\n        this.finishOp(tt.lt, 1);\n        return tt.lt;\n      }\n      return type;\n    }\n\n    toAssignableList(\n      exprList: Expression[],\n      trailingCommaLoc: Position | undefined | null,\n      isLHS: boolean,\n    ): void {\n      for (let i = 0; i < exprList.length; i++) {\n        const expr = exprList[i];\n        if (expr?.type === \"TSTypeCastExpression\") {\n          exprList[i] = this.typeCastToParameter(\n            expr as N.TsTypeCastExpression,\n          );\n        }\n      }\n      super.toAssignableList(exprList, trailingCommaLoc, isLHS);\n    }\n\n    typeCastToParameter(node: N.TsTypeCastExpression): N.Node {\n      node.expression.typeAnnotation = node.typeAnnotation;\n\n      this.resetEndLocation(node.expression, node.typeAnnotation.loc.end);\n\n      return node.expression;\n    }\n\n    shouldParseArrow(params: Array<N.Node>) {\n      if (this.match(tt.colon)) {\n        return params.every(expr => this.isAssignable(expr, true));\n      }\n      return super.shouldParseArrow(params);\n    }\n\n    shouldParseAsyncArrow(): boolean {\n      return this.match(tt.colon) || super.shouldParseAsyncArrow();\n    }\n\n    canHaveLeadingDecorator() {\n      // Avoid unnecessary lookahead in checking for abstract class unless needed!\n      return super.canHaveLeadingDecorator() || this.isAbstractClass();\n    }\n\n    jsxParseOpeningElementAfterName(\n      node: N.JSXOpeningElement,\n    ): N.JSXOpeningElement {\n      // handles `<Component<<T>`\n      if (this.match(tt.lt) || this.match(tt.bitShiftL)) {\n        const typeArguments = this.tsTryParseAndCatch(() =>\n          // @ts-expect-error: refine typings\n          this.tsParseTypeArgumentsInExpression(),\n        );\n        // @ts-expect-error: refine typings\n        if (typeArguments) node.typeParameters = typeArguments;\n      }\n      return super.jsxParseOpeningElementAfterName(node);\n    }\n\n    getGetterSetterExpectedParamCount(\n      method: N.ObjectMethod | N.ClassMethod,\n    ): number {\n      const baseCount = super.getGetterSetterExpectedParamCount(method);\n      const params = this.getObjectOrClassMethodParams(method);\n      const firstParam = params[0];\n      const hasContextParam = firstParam && this.isThisParam(firstParam);\n\n      return hasContextParam ? baseCount + 1 : baseCount;\n    }\n\n    parseCatchClauseParam(): N.Pattern {\n      const param = super.parseCatchClauseParam();\n      const type = this.tsTryParseTypeAnnotation();\n\n      if (type) {\n        param.typeAnnotation = type;\n        this.resetEndLocation(param);\n      }\n\n      return param;\n    }\n\n    tsInAmbientContext<T>(cb: () => T): T {\n      const oldIsAmbientContext = this.state.isAmbientContext;\n      this.state.isAmbientContext = true;\n      try {\n        return cb();\n      } finally {\n        this.state.isAmbientContext = oldIsAmbientContext;\n      }\n    }\n\n    parseClass<T extends N.Class>(\n      node: Undone<T>,\n      isStatement: boolean,\n      optionalId?: boolean,\n    ): T {\n      const oldInAbstractClass = this.state.inAbstractClass;\n      this.state.inAbstractClass = !!(node as any).abstract;\n      try {\n        return super.parseClass(node, isStatement, optionalId);\n      } finally {\n        this.state.inAbstractClass = oldInAbstractClass;\n      }\n    }\n\n    tsParseAbstractDeclaration(\n      node: any,\n      decorators: N.Decorator[] | null,\n    ): N.ClassDeclaration | N.TsInterfaceDeclaration | undefined | null {\n      if (this.match(tt._class)) {\n        node.abstract = true;\n        return this.maybeTakeDecorators(\n          decorators,\n          this.parseClass<N.ClassDeclaration>(\n            node as N.ClassDeclaration,\n            /* isStatement */ true,\n            /* optionalId */ false,\n          ),\n        );\n      } else if (this.isContextual(tt._interface)) {\n        // for invalid abstract interface\n\n        // To avoid\n        //   abstract interface\n        //   Foo {}\n        if (!this.hasFollowingLineBreak()) {\n          node.abstract = true;\n          this.raise(TSErrors.NonClassMethodPropertyHasAbstractModifer, {\n            at: node,\n          });\n          return this.tsParseInterfaceDeclaration(\n            node as N.TsInterfaceDeclaration,\n          );\n        }\n      } else {\n        this.unexpected(null, tt._class);\n      }\n    }\n\n    parseMethod<\n      T extends N.ObjectMethod | N.ClassMethod | N.ClassPrivateMethod,\n    >(\n      node: Undone<T>,\n      isGenerator: boolean,\n      isAsync: boolean,\n      isConstructor: boolean,\n      allowDirectSuper: boolean,\n      type: T[\"type\"],\n      inClassScope?: boolean,\n    ) {\n      const method = super.parseMethod<T>(\n        node,\n        isGenerator,\n        isAsync,\n        isConstructor,\n        allowDirectSuper,\n        type,\n        inClassScope,\n      );\n      // @ts-expect-error todo(flow->ts) property not defined for all types in union\n      if (method.abstract) {\n        const hasBody = this.hasPlugin(\"estree\")\n          ? // @ts-expect-error estree typings\n            !!method.value.body\n          : !!method.body;\n        if (hasBody) {\n          const { key } = method;\n          this.raise(TSErrors.AbstractMethodHasImplementation, {\n            at: method,\n            methodName:\n              key.type === \"Identifier\" && !method.computed\n                ? key.name\n                : `[${this.input.slice(key.start, key.end)}]`,\n          });\n        }\n      }\n      return method;\n    }\n\n    tsParseTypeParameterName(): N.Identifier | string {\n      const typeName: N.Identifier = this.parseIdentifier();\n      return process.env.BABEL_8_BREAKING ? typeName : typeName.name;\n    }\n\n    shouldParseAsAmbientContext(): boolean {\n      return !!this.getPluginOption(\"typescript\", \"dts\");\n    }\n\n    parse() {\n      if (this.shouldParseAsAmbientContext()) {\n        this.state.isAmbientContext = true;\n      }\n      return super.parse();\n    }\n\n    getExpression() {\n      if (this.shouldParseAsAmbientContext()) {\n        this.state.isAmbientContext = true;\n      }\n      return super.getExpression();\n    }\n\n    parseExportSpecifier(\n      node: Undone<N.ExportSpecifier>,\n      isString: boolean,\n      isInTypeExport: boolean,\n      isMaybeTypeOnly: boolean,\n    ) {\n      if (!isString && isMaybeTypeOnly) {\n        this.parseTypeOnlyImportExportSpecifier(\n          node,\n          /* isImport */ false,\n          isInTypeExport,\n        );\n        return this.finishNode<N.ExportSpecifier>(node, \"ExportSpecifier\");\n      }\n      node.exportKind = \"value\";\n      return super.parseExportSpecifier(\n        node,\n        isString,\n        isInTypeExport,\n        isMaybeTypeOnly,\n      );\n    }\n\n    parseImportSpecifier(\n      specifier: Undone<N.ImportSpecifier>,\n      importedIsString: boolean,\n      isInTypeOnlyImport: boolean,\n      isMaybeTypeOnly: boolean,\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n      bindingType: BindingTypes | undefined,\n    ): N.ImportSpecifier {\n      if (!importedIsString && isMaybeTypeOnly) {\n        this.parseTypeOnlyImportExportSpecifier(\n          specifier,\n          /* isImport */ true,\n          isInTypeOnlyImport,\n        );\n        return this.finishNode<N.ImportSpecifier>(specifier, \"ImportSpecifier\");\n      }\n      specifier.importKind = \"value\";\n      return super.parseImportSpecifier(\n        specifier,\n        importedIsString,\n        isInTypeOnlyImport,\n        isMaybeTypeOnly,\n        isInTypeOnlyImport ? BIND_TS_TYPE_IMPORT : BIND_FLAGS_TS_IMPORT,\n      );\n    }\n\n    parseTypeOnlyImportExportSpecifier(\n      node: any,\n      isImport: boolean,\n      isInTypeOnlyImportExport: boolean,\n    ): void {\n      const leftOfAsKey = isImport ? \"imported\" : \"local\";\n      const rightOfAsKey = isImport ? \"local\" : \"exported\";\n\n      let leftOfAs = node[leftOfAsKey];\n      let rightOfAs;\n\n      let hasTypeSpecifier = false;\n      let canParseAsKeyword = true;\n\n      const loc = leftOfAs.loc.start;\n\n      // https://github.com/microsoft/TypeScript/blob/fc4f9d83d5939047aa6bb2a43965c6e9bbfbc35b/src/compiler/parser.ts#L7411-L7456\n      // import { type } from \"mod\";          - hasTypeSpecifier: false, leftOfAs: type\n      // import { type as } from \"mod\";       - hasTypeSpecifier: true,  leftOfAs: as\n      // import { type as as } from \"mod\";    - hasTypeSpecifier: false, leftOfAs: type, rightOfAs: as\n      // import { type as as as } from \"mod\"; - hasTypeSpecifier: true,  leftOfAs: as,   rightOfAs: as\n      if (this.isContextual(tt._as)) {\n        // { type as ...? }\n        const firstAs = this.parseIdentifier();\n        if (this.isContextual(tt._as)) {\n          // { type as as ...? }\n          const secondAs = this.parseIdentifier();\n          if (tokenIsKeywordOrIdentifier(this.state.type)) {\n            // { type as as something }\n            hasTypeSpecifier = true;\n            leftOfAs = firstAs;\n            rightOfAs = isImport\n              ? this.parseIdentifier()\n              : this.parseModuleExportName();\n            canParseAsKeyword = false;\n          } else {\n            // { type as as }\n            rightOfAs = secondAs;\n            canParseAsKeyword = false;\n          }\n        } else if (tokenIsKeywordOrIdentifier(this.state.type)) {\n          // { type as something }\n          canParseAsKeyword = false;\n          rightOfAs = isImport\n            ? this.parseIdentifier()\n            : this.parseModuleExportName();\n        } else {\n          // { type as }\n          hasTypeSpecifier = true;\n          leftOfAs = firstAs;\n        }\n      } else if (tokenIsKeywordOrIdentifier(this.state.type)) {\n        // { type something ...? }\n        hasTypeSpecifier = true;\n        if (isImport) {\n          leftOfAs = this.parseIdentifier(true);\n          if (!this.isContextual(tt._as)) {\n            this.checkReservedWord(\n              leftOfAs.name,\n              leftOfAs.loc.start,\n              true,\n              true,\n            );\n          }\n        } else {\n          leftOfAs = this.parseModuleExportName();\n        }\n      }\n      if (hasTypeSpecifier && isInTypeOnlyImportExport) {\n        this.raise(\n          isImport\n            ? TSErrors.TypeModifierIsUsedInTypeImports\n            : TSErrors.TypeModifierIsUsedInTypeExports,\n          { at: loc },\n        );\n      }\n\n      node[leftOfAsKey] = leftOfAs;\n      node[rightOfAsKey] = rightOfAs;\n\n      const kindKey = isImport ? \"importKind\" : \"exportKind\";\n      node[kindKey] = hasTypeSpecifier ? \"type\" : \"value\";\n\n      if (canParseAsKeyword && this.eatContextual(tt._as)) {\n        node[rightOfAsKey] = isImport\n          ? this.parseIdentifier()\n          : this.parseModuleExportName();\n      }\n      if (!node[rightOfAsKey]) {\n        node[rightOfAsKey] = cloneIdentifier(node[leftOfAsKey]);\n      }\n      if (isImport) {\n        this.checkIdentifier(\n          node[rightOfAsKey],\n          hasTypeSpecifier ? BIND_TS_TYPE_IMPORT : BIND_FLAGS_TS_IMPORT,\n        );\n      }\n    }\n  };\n\nfunction isPossiblyLiteralEnum(expression: N.Expression): boolean {\n  if (expression.type !== \"MemberExpression\") return false;\n\n  const { computed, property } = expression;\n\n  if (\n    computed &&\n    property.type !== \"StringLiteral\" &&\n    (property.type !== \"TemplateLiteral\" || property.expressions.length > 0)\n  ) {\n    return false;\n  }\n\n  return isUncomputedMemberExpressionChain(expression.object);\n}\n\n// If a const declaration has no type annotation and is initialized to\n// a string literal, numeric literal, or enum reference, then it is\n// allowed. In an ideal world, we'd check whether init was *actually* an\n// enum reference, but we allow anything that \"could be\" a literal enum\n// in `isPossiblyLiteralEnum` since we don't have all the information\n// that the typescript compiler has.\nfunction isValidAmbientConstInitializer(\n  expression: N.Expression,\n  estree: boolean,\n): boolean {\n  const { type } = expression;\n  if (expression.extra?.parenthesized) {\n    return false;\n  }\n  if (estree) {\n    if (type === \"Literal\") {\n      const { value } = expression;\n      if (typeof value === \"string\" || typeof value === \"boolean\") {\n        return true;\n      }\n    }\n  } else {\n    if (type === \"StringLiteral\" || type === \"BooleanLiteral\") {\n      return true;\n    }\n  }\n  if (isNumber(expression, estree) || isNegativeNumber(expression, estree)) {\n    return true;\n  }\n  if (type === \"TemplateLiteral\" && expression.expressions.length === 0) {\n    return true;\n  }\n  if (isPossiblyLiteralEnum(expression)) {\n    return true;\n  }\n  return false;\n}\n\nfunction isNumber(expression: N.Expression, estree: boolean): boolean {\n  if (estree) {\n    return (\n      expression.type === \"Literal\" &&\n      (typeof expression.value === \"number\" || \"bigint\" in expression)\n    );\n  }\n  return (\n    expression.type === \"NumericLiteral\" || expression.type === \"BigIntLiteral\"\n  );\n}\n\nfunction isNegativeNumber(expression: N.Expression, estree: boolean): boolean {\n  if (expression.type === \"UnaryExpression\") {\n    const { operator, argument } = expression as N.UnaryExpression;\n    if (operator === \"-\" && isNumber(argument, estree)) {\n      return true;\n    }\n  }\n  return false;\n}\n\nfunction isUncomputedMemberExpressionChain(expression: N.Expression): boolean {\n  if (expression.type === \"Identifier\") return true;\n  if (expression.type !== \"MemberExpression\" || expression.computed) {\n    return false;\n  }\n\n  return isUncomputedMemberExpressionChain(expression.object);\n}\n"],"mappings":"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"}��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������lib/plugins/typescript/scope.js���������������������������������������������������������������������0000644�����������������00000007071�15120211212�0012640 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;
var _scope = require("../../util/scope");
var _scopeflags = require("../../util/scopeflags");
var _parseError = require("../../parse-error");
class TypeScriptScope extends _scope.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 _scope.default {
  constructor(...args) {
    super(...args);
    this.importsStack = [];
  }
  createScope(flags) {
    this.importsStack.push(new Set());
    return new TypeScriptScope(flags);
  }
  enter(flags) {
    if (flags == _scopeflags.SCOPE_TS_MODULE) {
      this.importsStack.push(new Set());
    }
    super.enter(flags);
  }
  exit() {
    const flags = super.exit();
    if (flags == _scopeflags.SCOPE_TS_MODULE) {
      this.importsStack.pop();
    }
    return flags;
  }
  hasImport(name, allowShadow) {
    const len = this.importsStack.length;
    if (this.importsStack[len - 1].has(name)) {
      return true;
    }
    if (!allowShadow && len > 1) {
      for (let i = 0; i < len - 1; i++) {
        if (this.importsStack[i].has(name)) return true;
      }
    }
    return false;
  }
  declareName(name, bindingType, loc) {
    if (bindingType & _scopeflags.BIND_FLAGS_TS_IMPORT) {
      if (this.hasImport(name, true)) {
        this.parser.raise(_parseError.Errors.VarRedeclaration, {
          at: loc,
          identifierName: name
        });
      }
      this.importsStack[this.importsStack.length - 1].add(name);
      return;
    }
    const scope = this.currentScope();
    if (bindingType & _scopeflags.BIND_FLAGS_TS_EXPORT_ONLY) {
      this.maybeExportDefined(scope, name);
      scope.exportOnlyBindings.add(name);
      return;
    }
    super.declareName(name, bindingType, loc);
    if (bindingType & _scopeflags.BIND_KIND_TYPE) {
      if (!(bindingType & _scopeflags.BIND_KIND_VALUE)) {
        this.checkRedeclarationInScope(scope, name, bindingType, loc);
        this.maybeExportDefined(scope, name);
      }
      scope.types.add(name);
    }
    if (bindingType & _scopeflags.BIND_FLAGS_TS_ENUM) scope.enums.add(name);
    if (bindingType & _scopeflags.BIND_FLAGS_TS_CONST_ENUM) scope.constEnums.add(name);
    if (bindingType & _scopeflags.BIND_FLAGS_CLASS) scope.classes.add(name);
  }
  isRedeclaredInScope(scope, name, bindingType) {
    if (scope.enums.has(name)) {
      if (bindingType & _scopeflags.BIND_FLAGS_TS_ENUM) {
        const isConst = !!(bindingType & _scopeflags.BIND_FLAGS_TS_CONST_ENUM);
        const wasConst = scope.constEnums.has(name);
        return isConst !== wasConst;
      }
      return true;
    }
    if (bindingType & _scopeflags.BIND_FLAGS_CLASS && scope.classes.has(name)) {
      if (scope.lexical.has(name)) {
        return !!(bindingType & _scopeflags.BIND_KIND_VALUE);
      } else {
        return false;
      }
    }
    if (bindingType & _scopeflags.BIND_KIND_TYPE && scope.types.has(name)) {
      return true;
    }
    return super.isRedeclaredInScope(scope, name, bindingType);
  }
  checkLocalExport(id) {
    const {
      name
    } = id;
    if (this.hasImport(name)) return;
    const len = this.scopeStack.length;
    for (let i = len - 1; i >= 0; i--) {
      const scope = this.scopeStack[i];
      if (scope.types.has(name) || scope.exportOnlyBindings.has(name)) return;
    }
    super.checkLocalExport(id);
  }
}
exports.default = TypeScriptScopeHandler;

//# sourceMappingURL=scope.js.map
�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������lib/plugins/typescript/scope.js.map�����������������������������������������������������������������0000644�����������������00000022467�15120211212�0013422 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������{"version":3,"names":["_scope","require","_scopeflags","_parseError","TypeScriptScope","Scope","constructor","args","types","Set","enums","constEnums","classes","exportOnlyBindings","TypeScriptScopeHandler","ScopeHandler","importsStack","createScope","flags","push","enter","SCOPE_TS_MODULE","exit","pop","hasImport","name","allowShadow","len","length","has","i","declareName","bindingType","loc","BIND_FLAGS_TS_IMPORT","parser","raise","Errors","VarRedeclaration","at","identifierName","add","scope","currentScope","BIND_FLAGS_TS_EXPORT_ONLY","maybeExportDefined","BIND_KIND_TYPE","BIND_KIND_VALUE","checkRedeclarationInScope","BIND_FLAGS_TS_ENUM","BIND_FLAGS_TS_CONST_ENUM","BIND_FLAGS_CLASS","isRedeclaredInScope","isConst","wasConst","lexical","checkLocalExport","id","scopeStack","exports","default"],"sources":["../../../src/plugins/typescript/scope.ts"],"sourcesContent":["import type { Position } from \"../../util/location\";\nimport ScopeHandler, { Scope } from \"../../util/scope\";\nimport {\n  BIND_KIND_TYPE,\n  BIND_FLAGS_TS_ENUM,\n  BIND_FLAGS_TS_CONST_ENUM,\n  BIND_FLAGS_TS_EXPORT_ONLY,\n  BIND_KIND_VALUE,\n  BIND_FLAGS_CLASS,\n  type ScopeFlags,\n  type BindingTypes,\n  BIND_FLAGS_TS_IMPORT,\n  SCOPE_TS_MODULE,\n} from \"../../util/scopeflags\";\nimport type * as N from \"../../types\";\nimport { Errors } from \"../../parse-error\";\n\nclass TypeScriptScope extends Scope {\n  types: Set<string> = new Set();\n\n  // enums (which are also in .types)\n  enums: Set<string> = new Set();\n\n  // const enums (which are also in .enums and .types)\n  constEnums: Set<string> = new Set();\n\n  // classes (which are also in .lexical) and interface (which are also in .types)\n  classes: Set<string> = new Set();\n\n  // namespaces and ambient functions (or classes) are too difficult to track,\n  // especially without type analysis.\n  // We need to track them anyway, to avoid \"X is not defined\" errors\n  // when exporting them.\n  exportOnlyBindings: Set<string> = new Set();\n}\n\n// See https://github.com/babel/babel/pull/9766#discussion_r268920730 for an\n// explanation of how typescript handles scope.\n\nexport default class TypeScriptScopeHandler extends ScopeHandler<TypeScriptScope> {\n  importsStack: Set<string>[] = [];\n\n  createScope(flags: ScopeFlags): TypeScriptScope {\n    this.importsStack.push(new Set()); // Always keep the top-level scope for export checks.\n\n    return new TypeScriptScope(flags);\n  }\n\n  enter(flags: number): void {\n    if (flags == SCOPE_TS_MODULE) {\n      this.importsStack.push(new Set());\n    }\n\n    super.enter(flags);\n  }\n\n  exit() {\n    const flags = super.exit();\n\n    if (flags == SCOPE_TS_MODULE) {\n      this.importsStack.pop();\n    }\n\n    return flags;\n  }\n\n  hasImport(name: string, allowShadow?: boolean) {\n    const len = this.importsStack.length;\n    if (this.importsStack[len - 1].has(name)) {\n      return true;\n    }\n    if (!allowShadow && len > 1) {\n      for (let i = 0; i < len - 1; i++) {\n        if (this.importsStack[i].has(name)) return true;\n      }\n    }\n    return false;\n  }\n\n  declareName(name: string, bindingType: BindingTypes, loc: Position) {\n    if (bindingType & BIND_FLAGS_TS_IMPORT) {\n      if (this.hasImport(name, true)) {\n        this.parser.raise(Errors.VarRedeclaration, {\n          at: loc,\n          identifierName: name,\n        });\n      }\n      this.importsStack[this.importsStack.length - 1].add(name);\n      return;\n    }\n\n    const scope = this.currentScope();\n    if (bindingType & BIND_FLAGS_TS_EXPORT_ONLY) {\n      this.maybeExportDefined(scope, name);\n      scope.exportOnlyBindings.add(name);\n      return;\n    }\n\n    super.declareName(name, bindingType, loc);\n\n    if (bindingType & BIND_KIND_TYPE) {\n      if (!(bindingType & BIND_KIND_VALUE)) {\n        // \"Value\" bindings have already been registered by the superclass.\n        this.checkRedeclarationInScope(scope, name, bindingType, loc);\n        this.maybeExportDefined(scope, name);\n      }\n      scope.types.add(name);\n    }\n    if (bindingType & BIND_FLAGS_TS_ENUM) scope.enums.add(name);\n    if (bindingType & BIND_FLAGS_TS_CONST_ENUM) scope.constEnums.add(name);\n    if (bindingType & BIND_FLAGS_CLASS) scope.classes.add(name);\n  }\n\n  isRedeclaredInScope(\n    scope: TypeScriptScope,\n    name: string,\n    bindingType: BindingTypes,\n  ): boolean {\n    if (scope.enums.has(name)) {\n      if (bindingType & BIND_FLAGS_TS_ENUM) {\n        // Enums can be merged with other enums if they are both\n        //  const or both non-const.\n        const isConst = !!(bindingType & BIND_FLAGS_TS_CONST_ENUM);\n        const wasConst = scope.constEnums.has(name);\n        return isConst !== wasConst;\n      }\n      return true;\n    }\n    if (bindingType & BIND_FLAGS_CLASS && scope.classes.has(name)) {\n      if (scope.lexical.has(name)) {\n        // Classes can be merged with interfaces\n        return !!(bindingType & BIND_KIND_VALUE);\n      } else {\n        // Interface can be merged with other classes or interfaces\n        return false;\n      }\n    }\n    if (bindingType & BIND_KIND_TYPE && scope.types.has(name)) {\n      return true;\n    }\n\n    return super.isRedeclaredInScope(scope, name, bindingType);\n  }\n\n  checkLocalExport(id: N.Identifier) {\n    const { name } = id;\n\n    if (this.hasImport(name)) return;\n\n    const len = this.scopeStack.length;\n    for (let i = len - 1; i >= 0; i--) {\n      const scope = this.scopeStack[i];\n      if (scope.types.has(name) || scope.exportOnlyBindings.has(name)) return;\n    }\n\n    super.checkLocalExport(id);\n  }\n}\n"],"mappings":"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"}���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������lib/plugins/v8intrinsic.js��������������������������������������������������������������������������0000644�����������������00000001643�15120211212�0011600 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;
var _types = require("../tokenizer/types");
var _default = superClass => class V8IntrinsicMixin extends superClass {
  parseV8Intrinsic() {
    if (this.match(54)) {
      const v8IntrinsicStartLoc = this.state.startLoc;
      const node = this.startNode();
      this.next();
      if ((0, _types.tokenIsIdentifier)(this.state.type)) {
        const name = this.parseIdentifierName();
        const identifier = this.createIdentifier(node, name);
        identifier.type = "V8IntrinsicIdentifier";
        if (this.match(10)) {
          return identifier;
        }
      }
      this.unexpected(v8IntrinsicStartLoc);
    }
  }
  parseExprAtom(refExpressionErrors) {
    return this.parseV8Intrinsic() || super.parseExprAtom(refExpressionErrors);
  }
};
exports.default = _default;

//# sourceMappingURL=v8intrinsic.js.map
���������������������������������������������������������������������������������������������lib/plugins/v8intrinsic.js.map����������������������������������������������������������������������0000644�����������������00000005147�15120211212�0012357 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������{"version":3,"names":["_types","require","_default","superClass","V8IntrinsicMixin","parseV8Intrinsic","match","v8IntrinsicStartLoc","state","startLoc","node","startNode","next","tokenIsIdentifier","type","name","parseIdentifierName","identifier","createIdentifier","unexpected","parseExprAtom","refExpressionErrors","exports","default"],"sources":["../../src/plugins/v8intrinsic.ts"],"sourcesContent":["import type Parser from \"../parser\";\nimport { tokenIsIdentifier, tt } from \"../tokenizer/types\";\nimport type * as N from \"../types\";\nimport type { ExpressionErrors } from \"../parser/util\";\n\nexport default (superClass: typeof Parser) =>\n  class V8IntrinsicMixin extends superClass implements Parser {\n    parseV8Intrinsic(): N.Expression {\n      if (this.match(tt.modulo)) {\n        const v8IntrinsicStartLoc = this.state.startLoc;\n        // let the `loc` of Identifier starts from `%`\n        const node = this.startNode<N.Identifier>();\n        this.next(); // eat '%'\n        if (tokenIsIdentifier(this.state.type)) {\n          const name = this.parseIdentifierName();\n          const identifier = this.createIdentifier(node, name);\n          // @ts-expect-error: avoid mutating AST types\n          identifier.type = \"V8IntrinsicIdentifier\";\n          if (this.match(tt.parenL)) {\n            return identifier;\n          }\n        }\n        this.unexpected(v8IntrinsicStartLoc);\n      }\n    }\n\n    /* ============================================================ *\n     * parser/expression.js                                         *\n     * ============================================================ */\n\n    parseExprAtom(refExpressionErrors?: ExpressionErrors | null): N.Expression {\n      return (\n        this.parseV8Intrinsic() || super.parseExprAtom(refExpressionErrors)\n      );\n    }\n  };\n"],"mappings":";;;;;;AACA,IAAAA,MAAA,GAAAC,OAAA;AAA2D,IAAAC,QAAA,GAI3CC,UAAyB,IACvC,MAAMC,gBAAgB,SAASD,UAAU,CAAmB;EAC1DE,gBAAgBA,CAAA,EAAiB;IAC/B,IAAI,IAAI,CAACC,KAAK,GAAU,CAAC,EAAE;MACzB,MAAMC,mBAAmB,GAAG,IAAI,CAACC,KAAK,CAACC,QAAQ;MAE/C,MAAMC,IAAI,GAAG,IAAI,CAACC,SAAS,CAAe,CAAC;MAC3C,IAAI,CAACC,IAAI,CAAC,CAAC;MACX,IAAI,IAAAC,wBAAiB,EAAC,IAAI,CAACL,KAAK,CAACM,IAAI,CAAC,EAAE;QACtC,MAAMC,IAAI,GAAG,IAAI,CAACC,mBAAmB,CAAC,CAAC;QACvC,MAAMC,UAAU,GAAG,IAAI,CAACC,gBAAgB,CAACR,IAAI,EAAEK,IAAI,CAAC;QAEpDE,UAAU,CAACH,IAAI,GAAG,uBAAuB;QACzC,IAAI,IAAI,CAACR,KAAK,GAAU,CAAC,EAAE;UACzB,OAAOW,UAAU;QACnB;MACF;MACA,IAAI,CAACE,UAAU,CAACZ,mBAAmB,CAAC;IACtC;EACF;EAMAa,aAAaA,CAACC,mBAA6C,EAAgB;IACzE,OACE,IAAI,CAAChB,gBAAgB,CAAC,CAAC,IAAI,KAAK,CAACe,aAAa,CAACC,mBAAmB,CAAC;EAEvE;AACF,CAAC;AAAAC,OAAA,CAAAC,OAAA,GAAArB,QAAA"}�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������lib/tokenizer/context.js����������������������������������������������������������������������������0000644�����������������00000001156�15120211212�0011334 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.types = exports.TokContext = void 0;
class TokContext {
  constructor(token, preserveSpace) {
    this.token = void 0;
    this.preserveSpace = void 0;
    this.token = token;
    this.preserveSpace = !!preserveSpace;
  }
}
exports.TokContext = TokContext;
const types = {
  brace: new TokContext("{"),
  j_oTag: new TokContext("<tag"),
  j_cTag: new TokContext("</tag"),
  j_expr: new TokContext("<tag>...</tag>", true)
};
exports.types = types;
{
  types.template = new TokContext("`", true);
}

//# sourceMappingURL=context.js.map
������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������lib/tokenizer/context.js.map������������������������������������������������������������������������0000644�����������������00000002727�15120211212�0012115 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������{"version":3,"names":["TokContext","constructor","token","preserveSpace","exports","types","brace","j_oTag","j_cTag","j_expr","template"],"sources":["../../src/tokenizer/context.ts"],"sourcesContent":["// 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(\"<tag\"), // JSX opening tag\n  j_cTag: new TokContext(\"</tag\"), // JSX closing tag\n  j_expr: new TokContext(\"<tag>...</tag>\", true), // JSX expressions\n};\n\nif (!process.env.BABEL_8_BREAKING) {\n  types.template = new TokContext(\"`\", true);\n}\n\nexport { types };\n"],"mappings":";;;;;;AAGO,MAAMA,UAAU,CAAC;EACtBC,WAAWA,CAACC,KAAa,EAAEC,aAAuB,EAAE;IAAA,KAKpDD,KAAK;IAAA,KACLC,aAAa;IALX,IAAI,CAACD,KAAK,GAAGA,KAAK;IAClB,IAAI,CAACC,aAAa,GAAG,CAAC,CAACA,aAAa;EACtC;AAIF;AAACC,OAAA,CAAAJ,UAAA,GAAAA,UAAA;AAED,MAAMK,KAEL,GAAG;EACFC,KAAK,EAAE,IAAIN,UAAU,CAAC,GAAG,CAAC;EAC1BO,MAAM,EAAE,IAAIP,UAAU,CAAC,MAAM,CAAC;EAC9BQ,MAAM,EAAE,IAAIR,UAAU,CAAC,OAAO,CAAC;EAC/BS,MAAM,EAAE,IAAIT,UAAU,CAAC,gBAAgB,EAAE,IAAI;AAC/C,CAAC;AAACI,OAAA,CAAAC,KAAA,GAAAA,KAAA;AAEiC;EACjCA,KAAK,CAACK,QAAQ,GAAG,IAAIV,UAAU,CAAC,GAAG,EAAE,IAAI,CAAC;AAC5C"}�����������������������������������������lib/tokenizer/index.js������������������������������������������������������������������������������0000644�����������������00000103207�15120211212�0010757 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = exports.Token = void 0;
var _location = require("../util/location");
var _comments = require("../parser/comments");
var _identifier = require("../util/identifier");
var _types = require("./types");
var _parseError = require("../parse-error");
var _whitespace = require("../util/whitespace");
var _state = require("./state");
var _helperStringParser = require("@babel/helper-string-parser");
const _excluded = ["at"],
  _excluded2 = ["at"];
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 buildPosition(pos, lineStart, curLine) {
  return new _location.Position(curLine, pos - lineStart, pos);
}
const VALID_REGEX_FLAGS = new Set([103, 109, 115, 105, 121, 117, 100, 118]);
class Token {
  constructor(state) {
    this.type = state.type;
    this.value = state.value;
    this.start = state.start;
    this.end = state.end;
    this.loc = new _location.SourceLocation(state.startLoc, state.endLoc);
  }
}
exports.Token = Token;
class Tokenizer extends _comments.default {
  constructor(options, input) {
    super();
    this.isLookahead = void 0;
    this.tokens = [];
    this.errorHandlers_readInt = {
      invalidDigit: (pos, lineStart, curLine, radix) => {
        if (!this.options.errorRecovery) return false;
        this.raise(_parseError.Errors.InvalidDigit, {
          at: buildPosition(pos, lineStart, curLine),
          radix
        });
        return true;
      },
      numericSeparatorInEscapeSequence: this.errorBuilder(_parseError.Errors.NumericSeparatorInEscapeSequence),
      unexpectedNumericSeparator: this.errorBuilder(_parseError.Errors.UnexpectedNumericSeparator)
    };
    this.errorHandlers_readCodePoint = Object.assign({}, this.errorHandlers_readInt, {
      invalidEscapeSequence: this.errorBuilder(_parseError.Errors.InvalidEscapeSequence),
      invalidCodePoint: this.errorBuilder(_parseError.Errors.InvalidCodePoint)
    });
    this.errorHandlers_readStringContents_string = Object.assign({}, this.errorHandlers_readCodePoint, {
      strictNumericEscape: (pos, lineStart, curLine) => {
        this.recordStrictModeErrors(_parseError.Errors.StrictNumericEscape, {
          at: buildPosition(pos, lineStart, curLine)
        });
      },
      unterminated: (pos, lineStart, curLine) => {
        throw this.raise(_parseError.Errors.UnterminatedString, {
          at: buildPosition(pos - 1, lineStart, curLine)
        });
      }
    });
    this.errorHandlers_readStringContents_template = Object.assign({}, this.errorHandlers_readCodePoint, {
      strictNumericEscape: this.errorBuilder(_parseError.Errors.StrictNumericEscape),
      unterminated: (pos, lineStart, curLine) => {
        throw this.raise(_parseError.Errors.UnterminatedTemplate, {
          at: buildPosition(pos, lineStart, curLine)
        });
      }
    });
    this.state = new _state.default();
    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) {
    _whitespace.skipWhiteSpace.lastIndex = pos;
    return _whitespace.skipWhiteSpace.test(this.input) ? _whitespace.skipWhiteSpace.lastIndex : pos;
  }
  lookaheadCharCode() {
    return this.input.charCodeAt(this.nextTokenStart());
  }
  nextTokenInLineStart() {
    return this.nextTokenInLineStartSince(this.state.pos);
  }
  nextTokenInLineStartSince(pos) {
    _whitespace.skipWhiteSpaceInLine.lastIndex = pos;
    return _whitespace.skipWhiteSpaceInLine.test(this.input) ? _whitespace.skipWhiteSpaceInLine.lastIndex : pos;
  }
  lookaheadInLineCharCode() {
    return this.input.charCodeAt(this.nextTokenInLineStart());
  }
  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(([toParseError, at]) => this.raise(toParseError, {
        at
      }));
      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(137);
      return;
    }
    this.getTokenFromCode(this.codePointAtPos(this.state.pos));
  }
  skipBlockComment(commentEnd) {
    let startLoc;
    if (!this.isLookahead) startLoc = this.state.curPosition();
    const start = this.state.pos;
    const end = this.input.indexOf(commentEnd, start + 2);
    if (end === -1) {
      throw this.raise(_parseError.Errors.UnterminatedComment, {
        at: this.state.curPosition()
      });
    }
    this.state.pos = end + commentEnd.length;
    _whitespace.lineBreakG.lastIndex = start + 2;
    while (_whitespace.lineBreakG.test(this.input) && _whitespace.lineBreakG.lastIndex <= end) {
      ++this.state.curLine;
      this.state.lineStart = _whitespace.lineBreakG.lastIndex;
    }
    if (this.isLookahead) return;
    const comment = {
      type: "CommentBlock",
      value: this.input.slice(start + 2, end),
      start,
      end: end + commentEnd.length,
      loc: new _location.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 (!(0, _whitespace.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 _location.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 ((0, _whitespace.isWhitespace)(ch)) {
            ++this.state.pos;
          } else if (ch === 45 && !this.inModule && this.options.annexB) {
            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 && this.options.annexB) {
            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(_parseError.Errors.UnexpectedDigitAfterHash, {
        at: this.state.curPosition()
      });
    }
    if (next === 123 || next === 91 && this.hasPlugin("recordAndTuple")) {
      this.expectPlugin("recordAndTuple");
      if (this.getPluginOption("recordAndTuple", "syntaxType") === "bar") {
        throw this.raise(next === 123 ? _parseError.Errors.RecordExpressionHashIncorrectStartSyntaxType : _parseError.Errors.TupleExpressionHashIncorrectStartSyntaxType, {
          at: this.state.curPosition()
        });
      }
      this.state.pos += 2;
      if (next === 123) {
        this.finishToken(7);
      } else {
        this.finishToken(1);
      }
    } else if ((0, _identifier.isIdentifierStart)(next)) {
      ++this.state.pos;
      this.finishToken(136, this.readWord1(next));
    } else if (next === 92) {
      ++this.state.pos;
      this.finishToken(136, 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 (!(0, _whitespace.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(_parseError.Errors.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(_parseError.Errors.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) {
        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(_parseError.Errors.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(_parseError.Errors.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 ((0, _identifier.isIdentifierStart)(code)) {
          this.readWord(code);
          return;
        }
    }
    throw this.raise(_parseError.Errors.InvalidOrUnexpectedToken, {
      at: this.state.curPosition(),
      unexpected: 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(_parseError.Errors.UnterminatedRegExp, {
          at: (0, _location.createPositionWithColumnOffset)(startLoc, 1)
        });
      }
      const ch = this.input.charCodeAt(pos);
      if ((0, _whitespace.isNewLine)(ch)) {
        throw this.raise(_parseError.Errors.UnterminatedRegExp, {
          at: (0, _location.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 = () => (0, _location.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) {
          if (mods.includes("u")) {
            this.raise(_parseError.Errors.IncompatibleRegExpUVFlags, {
              at: nextPos()
            });
          }
        } else if (cp === 117) {
          if (mods.includes("v")) {
            this.raise(_parseError.Errors.IncompatibleRegExpUVFlags, {
              at: nextPos()
            });
          }
        }
        if (mods.includes(char)) {
          this.raise(_parseError.Errors.DuplicateRegExpFlags, {
            at: nextPos()
          });
        }
      } else if ((0, _identifier.isIdentifierChar)(cp) || cp === 92) {
        this.raise(_parseError.Errors.MalformedRegExpFlags, {
          at: nextPos()
        });
      } else {
        break;
      }
      ++pos;
      mods += char;
    }
    this.state.pos = pos;
    this.finishToken(135, {
      pattern: content,
      flags: mods
    });
  }
  readInt(radix, len, forceLen = false, allowNumSeparator = true) {
    const {
      n,
      pos
    } = (0, _helperStringParser.readInt)(this.input, this.state.pos, this.state.lineStart, this.state.curLine, radix, len, forceLen, allowNumSeparator, this.errorHandlers_readInt, false);
    this.state.pos = pos;
    return n;
  }
  readRadixNumber(radix) {
    const startLoc = this.state.curPosition();
    let isBigInt = false;
    this.state.pos += 2;
    const val = this.readInt(radix);
    if (val == null) {
      this.raise(_parseError.Errors.InvalidDigit, {
        at: (0, _location.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(_parseError.Errors.InvalidDecimal, {
        at: startLoc
      });
    }
    if ((0, _identifier.isIdentifierStart)(this.codePointAtPos(this.state.pos))) {
      throw this.raise(_parseError.Errors.NumberIdentifier, {
        at: this.state.curPosition()
      });
    }
    if (isBigInt) {
      const str = this.input.slice(startLoc.index, this.state.pos).replace(/[_n]/g, "");
      this.finishToken(133, str);
      return;
    }
    this.finishToken(132, 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(_parseError.Errors.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(_parseError.Errors.StrictOctalLiteral, {
        at: startLoc
      });
      if (!this.state.strict) {
        const underscorePos = integer.indexOf("_");
        if (underscorePos > 0) {
          this.raise(_parseError.Errors.ZeroDigitNumericSeparator, {
            at: (0, _location.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(_parseError.Errors.InvalidOrMissingExponent, {
          at: startLoc
        });
      }
      isFloat = true;
      hasExponent = true;
      next = this.input.charCodeAt(this.state.pos);
    }
    if (next === 110) {
      if (isFloat || hasLeadingZero) {
        this.raise(_parseError.Errors.InvalidBigIntLiteral, {
          at: startLoc
        });
      }
      ++this.state.pos;
      isBigInt = true;
    }
    if (next === 109) {
      this.expectPlugin("decimal", this.state.curPosition());
      if (hasExponent || hasLeadingZero) {
        this.raise(_parseError.Errors.InvalidDecimal, {
          at: startLoc
        });
      }
      ++this.state.pos;
      isDecimal = true;
    }
    if ((0, _identifier.isIdentifierStart)(this.codePointAtPos(this.state.pos))) {
      throw this.raise(_parseError.Errors.NumberIdentifier, {
        at: this.state.curPosition()
      });
    }
    const str = this.input.slice(start, this.state.pos).replace(/[_mn]/g, "");
    if (isBigInt) {
      this.finishToken(133, str);
      return;
    }
    if (isDecimal) {
      this.finishToken(134, str);
      return;
    }
    const val = isOctal ? parseInt(str, 8) : parseFloat(str);
    this.finishToken(132, val);
  }
  readCodePoint(throwOnInvalid) {
    const {
      code,
      pos
    } = (0, _helperStringParser.readCodePoint)(this.input, this.state.pos, this.state.lineStart, this.state.curLine, throwOnInvalid, this.errorHandlers_readCodePoint);
    this.state.pos = pos;
    return code;
  }
  readString(quote) {
    const {
      str,
      pos,
      curLine,
      lineStart
    } = (0, _helperStringParser.readStringContents)(quote === 34 ? "double" : "single", this.input, this.state.pos + 1, this.state.lineStart, this.state.curLine, this.errorHandlers_readStringContents_string);
    this.state.pos = pos + 1;
    this.state.lineStart = lineStart;
    this.state.curLine = curLine;
    this.finishToken(131, str);
  }
  readTemplateContinuation() {
    if (!this.match(8)) {
      this.unexpected(null, 8);
    }
    this.state.pos--;
    this.readTemplateToken();
  }
  readTemplateToken() {
    const opening = this.input[this.state.pos];
    const {
      str,
      firstInvalidLoc,
      pos,
      curLine,
      lineStart
    } = (0, _helperStringParser.readStringContents)("template", this.input, this.state.pos + 1, this.state.lineStart, this.state.curLine, this.errorHandlers_readStringContents_template);
    this.state.pos = pos + 1;
    this.state.lineStart = lineStart;
    this.state.curLine = curLine;
    if (firstInvalidLoc) {
      this.state.firstInvalidTemplateEscapePos = new _location.Position(firstInvalidLoc.curLine, firstInvalidLoc.pos - firstInvalidLoc.lineStart, firstInvalidLoc.pos);
    }
    if (this.input.codePointAt(pos) === 96) {
      this.finishToken(24, firstInvalidLoc ? null : opening + str + "`");
    } else {
      this.state.pos++;
      this.finishToken(25, firstInvalidLoc ? null : opening + str + "${");
    }
  }
  recordStrictModeErrors(toParseError, {
    at
  }) {
    const index = at.index;
    if (this.state.strict && !this.state.strictErrors.has(index)) {
      this.raise(toParseError, {
        at
      });
    } else {
      this.state.strictErrors.set(index, [toParseError, at]);
    }
  }
  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 ((0, _identifier.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 ? _identifier.isIdentifierStart : _identifier.isIdentifierChar;
        if (this.input.charCodeAt(++this.state.pos) !== 117) {
          this.raise(_parseError.Errors.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(_parseError.Errors.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 = _types.keywords.get(word);
    if (type !== undefined) {
      this.finishToken(type, (0, _types.tokenLabelName)(type));
    } else {
      this.finishToken(130, word);
    }
  }
  checkKeywordEscapes() {
    const {
      type
    } = this.state;
    if ((0, _types.tokenIsKeyword)(type) && this.state.containsEsc) {
      this.raise(_parseError.Errors.InvalidEscapedReservedWord, {
        at: this.state.startLoc,
        reservedWord: (0, _types.tokenLabelName)(type)
      });
    }
  }
  raise(toParseError, raiseProperties) {
    const {
        at
      } = raiseProperties,
      details = _objectWithoutPropertiesLoose(raiseProperties, _excluded);
    const loc = at instanceof _location.Position ? at : at.loc.start;
    const error = toParseError({
      loc,
      details
    });
    if (!this.options.errorRecovery) throw error;
    if (!this.isLookahead) this.state.errors.push(error);
    return error;
  }
  raiseOverwrite(toParseError, raiseProperties) {
    const {
        at
      } = raiseProperties,
      details = _objectWithoutPropertiesLoose(raiseProperties, _excluded2);
    const loc = at instanceof _location.Position ? at : at.loc.start;
    const pos = loc.index;
    const errors = this.state.errors;
    for (let i = errors.length - 1; i >= 0; i--) {
      const error = errors[i];
      if (error.loc.index === pos) {
        return errors[i] = toParseError({
          loc,
          details
        });
      }
      if (error.loc.index < pos) break;
    }
    return this.raise(toParseError, raiseProperties);
  }
  updateContext(prevType) {}
  unexpected(loc, type) {
    throw this.raise(_parseError.Errors.UnexpectedToken, {
      expected: type ? (0, _types.tokenLabelName)(type) : null,
      at: loc != null ? loc : this.state.startLoc
    });
  }
  expectPlugin(pluginName, loc) {
    if (this.hasPlugin(pluginName)) {
      return true;
    }
    throw this.raise(_parseError.Errors.MissingPlugin, {
      at: loc != null ? loc : this.state.startLoc,
      missingPlugin: [pluginName]
    });
  }
  expectOnePlugin(pluginNames) {
    if (!pluginNames.some(name => this.hasPlugin(name))) {
      throw this.raise(_parseError.Errors.MissingOneOfPlugins, {
        at: this.state.startLoc,
        missingPlugin: pluginNames
      });
    }
  }
  errorBuilder(error) {
    return (pos, lineStart, curLine) => {
      this.raise(error, {
        at: buildPosition(pos, lineStart, curLine)
      });
    };
  }
}
exports.default = Tokenizer;

//# sourceMappingURL=index.js.map
�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������lib/tokenizer/index.js.map��������������������������������������������������������������������������0000644�����������������00000264415�15120211212�0011544 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������{"version":3,"names":["_location","require","_comments","_identifier","_types","_parseError","_whitespace","_state","_helperStringParser","_excluded","_excluded2","_objectWithoutPropertiesLoose","source","excluded","target","sourceKeys","Object","keys","key","i","length","indexOf","buildPosition","pos","lineStart","curLine","Position","VALID_REGEX_FLAGS","Set","Token","constructor","state","type","value","start","end","loc","SourceLocation","startLoc","endLoc","exports","Tokenizer","CommentsParser","options","input","isLookahead","tokens","errorHandlers_readInt","invalidDigit","radix","errorRecovery","raise","Errors","InvalidDigit","at","numericSeparatorInEscapeSequence","errorBuilder","NumericSeparatorInEscapeSequence","unexpectedNumericSeparator","UnexpectedNumericSeparator","errorHandlers_readCodePoint","assign","invalidEscapeSequence","InvalidEscapeSequence","invalidCodePoint","InvalidCodePoint","errorHandlers_readStringContents_string","strictNumericEscape","recordStrictModeErrors","StrictNumericEscape","unterminated","UnterminatedString","errorHandlers_readStringContents_template","UnterminatedTemplate","State","init","pushToken","token","tokensLength","push","next","checkKeywordEscapes","lastTokStart","lastTokEndLoc","lastTokStartLoc","nextToken","eat","match","createLookaheadState","context","curContext","inType","curPosition","lookahead","old","curr","nextTokenStart","nextTokenStartSince","skipWhiteSpace","lastIndex","test","lookaheadCharCode","charCodeAt","nextTokenInLineStart","nextTokenInLineStartSince","skipWhiteSpaceInLine","lookaheadInLineCharCode","codePointAtPos","cp","trail","setStrict","strict","strictErrors","forEach","toParseError","clear","skipSpace","finishToken","getTokenFromCode","skipBlockComment","commentEnd","UnterminatedComment","lineBreakG","comment","slice","skipLineComment","startSkip","ch","isNewLine","spaceStart","comments","loop","undefined","addComment","attachComment","isWhitespace","inModule","annexB","commentWhitespace","leadingNode","trailingNode","containingNode","commentStack","val","prevType","updateContext","replaceToken","readToken_numberSign","readToken_interpreter","nextPos","UnexpectedDigitAfterHash","hasPlugin","expectPlugin","getPluginOption","RecordExpressionHashIncorrectStartSyntaxType","TupleExpressionHashIncorrectStartSyntaxType","isIdentifierStart","readWord1","finishOp","readToken_dot","readNumber","readToken_slash","readToken_mult_modulo","code","width","readToken_pipe_amp","RecordExpressionBarIncorrectEndSyntaxType","TupleExpressionBarIncorrectEndSyntaxType","readToken_caret","proposal","topicToken","lookaheadCh","codePointAt","unexpected","readToken_atSign","readToken_plus_min","readToken_lt","readToken_gt","size","readToken_eq_excl","readToken_question","next2","TupleExpressionBarIncorrectStartSyntaxType","RecordExpressionBarIncorrectStartSyntaxType","readTemplateToken","readRadixNumber","readString","readWord","InvalidOrUnexpectedToken","String","fromCodePoint","str","readRegexp","escaped","inClass","UnterminatedRegExp","createPositionWithColumnOffset","content","mods","char","fromCharCode","has","includes","IncompatibleRegExpUVFlags","DuplicateRegExpFlags","isIdentifierChar","MalformedRegExpFlags","pattern","flags","readInt","len","forceLen","allowNumSeparator","n","isBigInt","InvalidDecimal","NumberIdentifier","index","replace","startsWithDot","isFloat","isDecimal","hasExponent","isOctal","InvalidNumber","hasLeadingZero","integer","StrictOctalLiteral","underscorePos","ZeroDigitNumericSeparator","InvalidOrMissingExponent","InvalidBigIntLiteral","parseInt","parseFloat","readCodePoint","throwOnInvalid","quote","readStringContents","readTemplateContinuation","opening","firstInvalidLoc","firstInvalidTemplateEscapePos","set","firstCode","containsEsc","word","chunkStart","escStart","identifierCheck","MissingUnicodeEscape","esc","EscapedCharNotAnIdentifier","keywordTypes","get","tokenLabelName","tokenIsKeyword","InvalidEscapedReservedWord","reservedWord","raiseProperties","details","error","errors","raiseOverwrite","UnexpectedToken","expected","pluginName","MissingPlugin","missingPlugin","expectOnePlugin","pluginNames","some","name","MissingOneOfPlugins","default"],"sources":["../../src/tokenizer/index.ts"],"sourcesContent":["/*:: declare var invariant; */\n\nimport type { Options } from \"../options\";\nimport {\n  Position,\n  SourceLocation,\n  createPositionWithColumnOffset,\n} from \"../util/location\";\nimport CommentsParser, { type CommentWhitespace } from \"../parser/comments\";\nimport type * 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 {\n  Errors,\n  type ParseError,\n  type ParseErrorConstructor,\n  type RaiseProperties,\n} from \"../parse-error\";\nimport {\n  lineBreakG,\n  isNewLine,\n  isWhitespace,\n  skipWhiteSpace,\n  skipWhiteSpaceInLine,\n} from \"../util/whitespace\";\nimport State from \"./state\";\nimport type { LookaheadState, DeferredStrictError } from \"./state\";\n\nimport {\n  readInt,\n  readCodePoint,\n  readStringContents,\n  type IntErrorHandlers,\n  type CodePointErrorHandlers,\n  type StringContentsErrorHandlers,\n} from \"@babel/helper-string-parser\";\n\nimport type { Plugin } from \"../typings\";\n\nfunction buildPosition(pos: number, lineStart: number, curLine: number) {\n  return new Position(curLine, pos - lineStart, pos);\n}\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  charCodes.lowercaseV,\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 abstract class Tokenizer extends CommentsParser {\n  isLookahead: boolean;\n\n  // Token store.\n  tokens: Array<Token | N.Comment> = [];\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  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  match(type: TokenType): boolean {\n    return this.state.type === type;\n  }\n\n  /**\n   * Create a LookaheadState from current parser state\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  lookahead(): LookaheadState {\n    const old = this.state;\n    // @ts-expect-error For performance we use a simplified tokenizer state structure\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  /**\n   * Similar to nextToken, but it will stop at line break when it is seen before the next token\n   *\n   * @returns {number} position of the next token start or line break, whichever is seen first.\n   * @memberof Tokenizer\n   */\n  nextTokenInLineStart(): number {\n    return this.nextTokenInLineStartSince(this.state.pos);\n  }\n\n  nextTokenInLineStartSince(pos: number): number {\n    skipWhiteSpaceInLine.lastIndex = pos;\n    return skipWhiteSpaceInLine.test(this.input)\n      ? skipWhiteSpaceInLine.lastIndex\n      : pos;\n  }\n\n  /**\n   * Similar to lookaheadCharCode, but it will return the char code of line break if it is\n   * seen before the next token\n   *\n   * @returns {number} char code of the next token start or line break, whichever is seen first.\n   * @memberof Tokenizer\n   */\n  lookaheadInLineCharCode(): number {\n    return this.input.charCodeAt(this.nextTokenInLineStart());\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(([toParseError, at]) =>\n        this.raise(toParseError, { at }),\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 properties.\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  // Skips a block comment, whose end is marked by commentEnd.\n  // *-/ is used by the Flow plugin, when parsing block comments nested\n  // inside Flow comments.\n  skipBlockComment(commentEnd: \"*/\" | \"*-/\"): N.CommentBlock | undefined {\n    let startLoc;\n    if (!this.isLookahead) startLoc = this.state.curPosition();\n    const start = this.state.pos;\n    const end = this.input.indexOf(commentEnd, 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 + commentEnd.length;\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.CommentBlock = {\n      type: \"CommentBlock\",\n      value: this.input.slice(start + 2, end),\n      start,\n      end: end + commentEnd.length,\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 | undefined {\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.CommentLine = {\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 (\n            ch === charCodes.dash &&\n            !this.inModule &&\n            this.options.annexB\n          ) {\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 (\n            ch === charCodes.lessThan &&\n            !this.inModule &&\n            this.options.annexB\n          ) {\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              // `<!--`, an XML-style comment that should be interpreted as a line comment\n              const comment = this.skipLineComment(4);\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 {\n            break loop;\n          }\n      }\n    }\n\n    if (comments.length > 0) {\n      const end = this.state.pos;\n      const commentWhitespace: CommentWhitespace = {\n        start: spaceStart,\n        end,\n        comments,\n        leadingNode: null,\n        trailingNode: null,\n        containingNode: null,\n      };\n      this.state.commentStack.push(commentWhitespace);\n    }\n  }\n\n  // Called at the end of every token. Sets `end`, `val`, and\n  // maintains `context` and `canStartJSXElement`, and skips the space after\n  // the token, so that the next one's `start` will point at the\n  // right position.\n\n  finishToken(type: TokenType, val?: any): void {\n    this.state.end = this.state.pos;\n    this.state.endLoc = this.state.curPosition();\n    const prevType = this.state.type;\n    this.state.type = type;\n    this.state.value = val;\n\n    if (!this.isLookahead) {\n      this.updateContext(prevType);\n    }\n  }\n\n  replaceToken(type: TokenType): void {\n    this.state.type = type;\n    // @ts-expect-error the prevType of updateContext is required\n    // only when the new type is tt.slash/tt.jsxTagEnd\n    this.updateContext();\n  }\n\n  // ### Token reading\n\n  // This is the function that is called to fetch the next token. It\n  // is somewhat obscure, because it works in character codes rather\n  // than characters, and because operator parsing has been inlined\n  // into it.\n  //\n  // All in the name of speed.\n\n  // number sign is \"#\"\n  readToken_numberSign(): void {\n    if (this.state.pos === 0 && this.readToken_interpreter()) {\n      return;\n    }\n\n    const nextPos = this.state.pos + 1;\n    const next = this.codePointAtPos(nextPos);\n    if (next >= charCodes.digit0 && next <= charCodes.digit9) {\n      throw this.raise(Errors.UnexpectedDigitAfterHash, {\n        at: this.state.curPosition(),\n      });\n    }\n\n    if (\n      next === charCodes.leftCurlyBrace ||\n      (next === charCodes.leftSquareBracket && this.hasPlugin(\"recordAndTuple\"))\n    ) {\n      // When we see `#{`, it is likely to be a hash record.\n      // However we don't yell at `#[` since users may intend to use \"computed private fields\",\n      // which is not allowed in the spec. Throwing expecting recordAndTuple is\n      // misleading\n      this.expectPlugin(\"recordAndTuple\");\n      if (this.getPluginOption(\"recordAndTuple\", \"syntaxType\") === \"bar\") {\n        throw this.raise(\n          next === charCodes.leftCurlyBrace\n            ? Errors.RecordExpressionHashIncorrectStartSyntaxType\n            : Errors.TupleExpressionHashIncorrectStartSyntaxType,\n          { at: this.state.curPosition() },\n        );\n      }\n\n      this.state.pos += 2;\n      if (next === charCodes.leftCurlyBrace) {\n        // #{\n        this.finishToken(tt.braceHashL);\n      } else {\n        // #[\n        this.finishToken(tt.bracketHashL);\n      }\n    } else if (isIdentifierStart(next)) {\n      ++this.state.pos;\n      this.finishToken(tt.privateName, this.readWord1(next));\n    } else if (next === charCodes.backslash) {\n      ++this.state.pos;\n      this.finishToken(tt.privateName, this.readWord1());\n    } else {\n      this.finishOp(tt.hash, 1);\n    }\n  }\n\n  readToken_dot(): void {\n    const next = this.input.charCodeAt(this.state.pos + 1);\n    if (next >= charCodes.digit0 && next <= charCodes.digit9) {\n      this.readNumber(true);\n      return;\n    }\n\n    if (\n      next === charCodes.dot &&\n      this.input.charCodeAt(this.state.pos + 2) === charCodes.dot\n    ) {\n      this.state.pos += 3;\n      this.finishToken(tt.ellipsis);\n    } else {\n      ++this.state.pos;\n      this.finishToken(tt.dot);\n    }\n  }\n\n  readToken_slash(): void {\n    const next = this.input.charCodeAt(this.state.pos + 1);\n    if (next === charCodes.equalsTo) {\n      this.finishOp(tt.slashAssign, 2);\n    } else {\n      this.finishOp(tt.slash, 1);\n    }\n  }\n\n  readToken_interpreter(): boolean {\n    if (this.state.pos !== 0 || this.length < 2) return false;\n\n    let ch = this.input.charCodeAt(this.state.pos + 1);\n    if (ch !== charCodes.exclamationMark) return false;\n\n    const start = this.state.pos;\n    this.state.pos += 1;\n\n    while (!isNewLine(ch) && ++this.state.pos < this.length) {\n      ch = this.input.charCodeAt(this.state.pos);\n    }\n\n    const value = this.input.slice(start + 2, this.state.pos);\n\n    this.finishToken(tt.interpreterDirective, value);\n\n    return true;\n  }\n\n  readToken_mult_modulo(code: number): void {\n    // '%' or '*'\n    let type = code === charCodes.asterisk ? tt.star : tt.modulo;\n    let width = 1;\n    let next = this.input.charCodeAt(this.state.pos + 1);\n\n    // Exponentiation operator '**'\n    if (code === charCodes.asterisk && next === charCodes.asterisk) {\n      width++;\n      next = this.input.charCodeAt(this.state.pos + 2);\n      type = tt.exponent;\n    }\n\n    // '%=' or '*='\n    if (next === charCodes.equalsTo && !this.state.inType) {\n      width++;\n      // `tt.moduloAssign` is only needed to support % as a Hack-pipe topic token.\n      // If the proposal ends up choosing a different token,\n      // it can be merged with tt.assign.\n      type = code === charCodes.percentSign ? tt.moduloAssign : tt.assign;\n    }\n\n    this.finishOp(type, width);\n  }\n\n  readToken_pipe_amp(code: number): void {\n    // '||' '&&' '||=' '&&='\n    const next = this.input.charCodeAt(this.state.pos + 1);\n\n    if (next === code) {\n      if (this.input.charCodeAt(this.state.pos + 2) === charCodes.equalsTo) {\n        this.finishOp(tt.assign, 3);\n      } else {\n        this.finishOp(\n          code === charCodes.verticalBar ? tt.logicalOR : tt.logicalAND,\n          2,\n        );\n      }\n      return;\n    }\n\n    if (code === charCodes.verticalBar) {\n      // '|>'\n      if (next === charCodes.greaterThan) {\n        this.finishOp(tt.pipeline, 2);\n        return;\n      }\n      // '|}'\n      if (\n        this.hasPlugin(\"recordAndTuple\") &&\n        next === charCodes.rightCurlyBrace\n      ) {\n        if (this.getPluginOption(\"recordAndTuple\", \"syntaxType\") !== \"bar\") {\n          throw this.raise(Errors.RecordExpressionBarIncorrectEndSyntaxType, {\n            at: this.state.curPosition(),\n          });\n        }\n        this.state.pos += 2;\n        this.finishToken(tt.braceBarR);\n        return;\n      }\n\n      // '|]'\n      if (\n        this.hasPlugin(\"recordAndTuple\") &&\n        next === charCodes.rightSquareBracket\n      ) {\n        if (this.getPluginOption(\"recordAndTuple\", \"syntaxType\") !== \"bar\") {\n          throw this.raise(Errors.TupleExpressionBarIncorrectEndSyntaxType, {\n            at: this.state.curPosition(),\n          });\n        }\n        this.state.pos += 2;\n        this.finishToken(tt.bracketBarR);\n        return;\n      }\n    }\n\n    if (next === charCodes.equalsTo) {\n      this.finishOp(tt.assign, 2);\n      return;\n    }\n\n    this.finishOp(\n      code === charCodes.verticalBar ? tt.bitwiseOR : tt.bitwiseAND,\n      1,\n    );\n  }\n\n  readToken_caret(): void {\n    const next = this.input.charCodeAt(this.state.pos + 1);\n\n    // '^='\n    if (next === charCodes.equalsTo && !this.state.inType) {\n      // `tt.xorAssign` is only needed to support ^ as a Hack-pipe topic token.\n      // If the proposal ends up choosing a different token,\n      // it can be merged with tt.assign.\n      this.finishOp(tt.xorAssign, 2);\n    }\n    // '^^'\n    else if (\n      next === charCodes.caret &&\n      // If the ^^ token is not enabled, we don't throw but parse two single ^s\n      // because it could be a ^ hack token followed by a ^ binary operator.\n      this.hasPlugin([\n        \"pipelineOperator\",\n        { proposal: \"hack\", topicToken: \"^^\" },\n      ])\n    ) {\n      this.finishOp(tt.doubleCaret, 2);\n\n      // `^^^` is forbidden and must be separated by a space.\n      const lookaheadCh = this.input.codePointAt(this.state.pos);\n      if (lookaheadCh === charCodes.caret) {\n        this.unexpected();\n      }\n    }\n    // '^'\n    else {\n      this.finishOp(tt.bitwiseXOR, 1);\n    }\n  }\n\n  readToken_atSign(): void {\n    const next = this.input.charCodeAt(this.state.pos + 1);\n\n    // '@@'\n    if (\n      next === charCodes.atSign &&\n      this.hasPlugin([\n        \"pipelineOperator\",\n        { proposal: \"hack\", topicToken: \"@@\" },\n      ])\n    ) {\n      this.finishOp(tt.doubleAt, 2);\n    }\n    // '@'\n    else {\n      this.finishOp(tt.at, 1);\n    }\n  }\n\n  readToken_plus_min(code: number): void {\n    // '+-'\n    const next = this.input.charCodeAt(this.state.pos + 1);\n\n    if (next === code) {\n      this.finishOp(tt.incDec, 2);\n      return;\n    }\n\n    if (next === charCodes.equalsTo) {\n      this.finishOp(tt.assign, 2);\n    } else {\n      this.finishOp(tt.plusMin, 1);\n    }\n  }\n\n  readToken_lt(): void {\n    // '<'\n    const { pos } = this.state;\n    const next = this.input.charCodeAt(pos + 1);\n\n    if (next === charCodes.lessThan) {\n      if (this.input.charCodeAt(pos + 2) === charCodes.equalsTo) {\n        this.finishOp(tt.assign, 3);\n        return;\n      }\n      this.finishOp(tt.bitShiftL, 2);\n      return;\n    }\n\n    if (next === charCodes.equalsTo) {\n      // <=\n      this.finishOp(tt.relational, 2);\n      return;\n    }\n\n    this.finishOp(tt.lt, 1);\n  }\n\n  readToken_gt(): void {\n    // '>'\n    const { pos } = this.state;\n    const next = this.input.charCodeAt(pos + 1);\n\n    if (next === charCodes.greaterThan) {\n      const size =\n        this.input.charCodeAt(pos + 2) === charCodes.greaterThan ? 3 : 2;\n      if (this.input.charCodeAt(pos + size) === charCodes.equalsTo) {\n        this.finishOp(tt.assign, size + 1);\n        return;\n      }\n      this.finishOp(tt.bitShiftR, size);\n      return;\n    }\n\n    if (next === charCodes.equalsTo) {\n      // <= | >=\n      this.finishOp(tt.relational, 2);\n      return;\n    }\n\n    this.finishOp(tt.gt, 1);\n  }\n\n  readToken_eq_excl(code: number): void {\n    // '=!'\n    const next = this.input.charCodeAt(this.state.pos + 1);\n    if (next === charCodes.equalsTo) {\n      this.finishOp(\n        tt.equality,\n        this.input.charCodeAt(this.state.pos + 2) === charCodes.equalsTo\n          ? 3\n          : 2,\n      );\n      return;\n    }\n    if (code === charCodes.equalsTo && next === charCodes.greaterThan) {\n      // '=>'\n      this.state.pos += 2;\n      this.finishToken(tt.arrow);\n      return;\n    }\n    this.finishOp(code === charCodes.equalsTo ? tt.eq : tt.bang, 1);\n  }\n\n  readToken_question(): void {\n    // '?'\n    const next = this.input.charCodeAt(this.state.pos + 1);\n    const next2 = this.input.charCodeAt(this.state.pos + 2);\n    if (next === charCodes.questionMark) {\n      if (next2 === charCodes.equalsTo) {\n        // '??='\n        this.finishOp(tt.assign, 3);\n      } else {\n        // '??'\n        this.finishOp(tt.nullishCoalescing, 2);\n      }\n    } else if (\n      next === charCodes.dot &&\n      !(next2 >= charCodes.digit0 && next2 <= charCodes.digit9)\n    ) {\n      // '.' not followed by a number\n      this.state.pos += 2;\n      this.finishToken(tt.questionDot);\n    } else {\n      ++this.state.pos;\n      this.finishToken(tt.question);\n    }\n  }\n\n  getTokenFromCode(code: number): void {\n    switch (code) {\n      // The interpretation of a dot depends on whether it is followed\n      // by a digit or another two dots.\n\n      case charCodes.dot:\n        this.readToken_dot();\n        return;\n      // Punctuation tokens.\n      case charCodes.leftParenthesis:\n        ++this.state.pos;\n        this.finishToken(tt.parenL);\n        return;\n      case charCodes.rightParenthesis:\n        ++this.state.pos;\n        this.finishToken(tt.parenR);\n        return;\n      case charCodes.semicolon:\n        ++this.state.pos;\n        this.finishToken(tt.semi);\n        return;\n      case charCodes.comma:\n        ++this.state.pos;\n        this.finishToken(tt.comma);\n        return;\n      case charCodes.leftSquareBracket:\n        if (\n          this.hasPlugin(\"recordAndTuple\") &&\n          this.input.charCodeAt(this.state.pos + 1) === charCodes.verticalBar\n        ) {\n          if (this.getPluginOption(\"recordAndTuple\", \"syntaxType\") !== \"bar\") {\n            throw this.raise(\n              Errors.TupleExpressionBarIncorrectStartSyntaxType,\n              { at: this.state.curPosition() },\n            );\n          }\n\n          // [|\n          this.state.pos += 2;\n          this.finishToken(tt.bracketBarL);\n        } else {\n          ++this.state.pos;\n          this.finishToken(tt.bracketL);\n        }\n        return;\n      case charCodes.rightSquareBracket:\n        ++this.state.pos;\n        this.finishToken(tt.bracketR);\n        return;\n      case charCodes.leftCurlyBrace:\n        if (\n          this.hasPlugin(\"recordAndTuple\") &&\n          this.input.charCodeAt(this.state.pos + 1) === charCodes.verticalBar\n        ) {\n          if (this.getPluginOption(\"recordAndTuple\", \"syntaxType\") !== \"bar\") {\n            throw this.raise(\n              Errors.RecordExpressionBarIncorrectStartSyntaxType,\n              { at: this.state.curPosition() },\n            );\n          }\n\n          // {|\n          this.state.pos += 2;\n          this.finishToken(tt.braceBarL);\n        } else {\n          ++this.state.pos;\n          this.finishToken(tt.braceL);\n        }\n        return;\n      case charCodes.rightCurlyBrace:\n        ++this.state.pos;\n        this.finishToken(tt.braceR);\n        return;\n\n      case charCodes.colon:\n        if (\n          this.hasPlugin(\"functionBind\") &&\n          this.input.charCodeAt(this.state.pos + 1) === charCodes.colon\n        ) {\n          this.finishOp(tt.doubleColon, 2);\n        } else {\n          ++this.state.pos;\n          this.finishToken(tt.colon);\n        }\n        return;\n\n      case charCodes.questionMark:\n        this.readToken_question();\n        return;\n\n      case charCodes.graveAccent:\n        this.readTemplateToken();\n        return;\n\n      case charCodes.digit0: {\n        const next = this.input.charCodeAt(this.state.pos + 1);\n        // '0x', '0X' - hex number\n        if (next === charCodes.lowercaseX || next === charCodes.uppercaseX) {\n          this.readRadixNumber(16);\n          return;\n        }\n        // '0o', '0O' - octal number\n        if (next === charCodes.lowercaseO || next === charCodes.uppercaseO) {\n          this.readRadixNumber(8);\n          return;\n        }\n        // '0b', '0B' - binary number\n        if (next === charCodes.lowercaseB || next === charCodes.uppercaseB) {\n          this.readRadixNumber(2);\n          return;\n        }\n      }\n      // Anything else beginning with a digit is an integer, octal\n      // number, or float. (fall through)\n      case charCodes.digit1:\n      case charCodes.digit2:\n      case charCodes.digit3:\n      case charCodes.digit4:\n      case charCodes.digit5:\n      case charCodes.digit6:\n      case charCodes.digit7:\n      case charCodes.digit8:\n      case charCodes.digit9:\n        this.readNumber(false);\n        return;\n\n      // Quotes produce strings.\n      case charCodes.quotationMark:\n      case charCodes.apostrophe:\n        this.readString(code);\n        return;\n\n      // Operators are parsed inline in tiny state machines. '=' (charCodes.equalsTo) is\n      // often referred to. `finishOp` simply skips the amount of\n      // characters it is given as second argument, and returns a token\n      // of the type given by its first argument.\n\n      case charCodes.slash:\n        this.readToken_slash();\n        return;\n\n      case charCodes.percentSign:\n      case charCodes.asterisk:\n        this.readToken_mult_modulo(code);\n        return;\n\n      case charCodes.verticalBar:\n      case charCodes.ampersand:\n        this.readToken_pipe_amp(code);\n        return;\n\n      case charCodes.caret:\n        this.readToken_caret();\n        return;\n\n      case charCodes.plusSign:\n      case charCodes.dash:\n        this.readToken_plus_min(code);\n        return;\n\n      case charCodes.lessThan:\n        this.readToken_lt();\n        return;\n\n      case charCodes.greaterThan:\n        this.readToken_gt();\n        return;\n\n      case charCodes.equalsTo:\n      case charCodes.exclamationMark:\n        this.readToken_eq_excl(code);\n        return;\n\n      case charCodes.tilde:\n        this.finishOp(tt.tilde, 1);\n        return;\n\n      case charCodes.atSign:\n        this.readToken_atSign();\n        return;\n\n      case charCodes.numberSign:\n        this.readToken_numberSign();\n        return;\n\n      case charCodes.backslash:\n        this.readWord();\n        return;\n\n      default:\n        if (isIdentifierStart(code)) {\n          this.readWord(code);\n          return;\n        }\n    }\n\n    throw this.raise(Errors.InvalidOrUnexpectedToken, {\n      at: this.state.curPosition(),\n      unexpected: String.fromCodePoint(code),\n    });\n  }\n\n  finishOp(type: TokenType, size: number): void {\n    const str = this.input.slice(this.state.pos, this.state.pos + size);\n    this.state.pos += size;\n    this.finishToken(type, str);\n  }\n\n  readRegexp(): void {\n    const startLoc = this.state.startLoc;\n    const start = this.state.start + 1;\n    let escaped, inClass;\n    let { pos } = this.state;\n    for (; ; ++pos) {\n      if (pos >= this.length) {\n        // FIXME: explain\n        throw this.raise(Errors.UnterminatedRegExp, {\n          at: createPositionWithColumnOffset(startLoc, 1),\n        });\n      }\n      const ch = this.input.charCodeAt(pos);\n      if (isNewLine(ch)) {\n        throw this.raise(Errors.UnterminatedRegExp, {\n          at: createPositionWithColumnOffset(startLoc, 1),\n        });\n      }\n      if (escaped) {\n        escaped = false;\n      } else {\n        if (ch === charCodes.leftSquareBracket) {\n          inClass = true;\n        } else if (ch === charCodes.rightSquareBracket && inClass) {\n          inClass = false;\n        } else if (ch === charCodes.slash && !inClass) {\n          break;\n        }\n        escaped = ch === charCodes.backslash;\n      }\n    }\n    const content = this.input.slice(start, pos);\n    ++pos;\n\n    let mods = \"\";\n\n    const nextPos = () =>\n      // (pos + 1) + 1 - start\n      createPositionWithColumnOffset(startLoc, pos + 2 - start);\n\n    while (pos < this.length) {\n      const cp = this.codePointAtPos(pos);\n      // It doesn't matter if cp > 0xffff, the loop will either throw or break because we check on cp\n      const char = String.fromCharCode(cp);\n\n      // @ts-expect-error VALID_REGEX_FLAGS.has should accept expanded type: number\n      if (VALID_REGEX_FLAGS.has(cp)) {\n        if (cp === charCodes.lowercaseV) {\n          if (mods.includes(\"u\")) {\n            this.raise(Errors.IncompatibleRegExpUVFlags, { at: nextPos() });\n          }\n        } else if (cp === charCodes.lowercaseU) {\n          if (mods.includes(\"v\")) {\n            this.raise(Errors.IncompatibleRegExpUVFlags, { at: nextPos() });\n          }\n        }\n        if (mods.includes(char)) {\n          this.raise(Errors.DuplicateRegExpFlags, { at: nextPos() });\n        }\n      } else if (isIdentifierChar(cp) || cp === charCodes.backslash) {\n        this.raise(Errors.MalformedRegExpFlags, { at: nextPos() });\n      } else {\n        break;\n      }\n\n      ++pos;\n      mods += char;\n    }\n    this.state.pos = pos;\n\n    this.finishToken(tt.regexp, {\n      pattern: content,\n      flags: mods,\n    });\n  }\n\n  // Read an integer in the given radix. Return null if zero digits\n  // were read, the integer value otherwise. When `len` is given, this\n  // will return `null` unless the integer has exactly `len` digits.\n  // When `forceLen` is `true`, it means that we already know that in case\n  // of a malformed number we have to skip `len` characters anyway, instead\n  // of bailing out early. For example, in \"\\u{123Z}\" we want to read up to }\n  // anyway, while in \"\\u00Z\" we will stop at Z instead of consuming four\n  // characters (and thus the closing quote).\n\n  readInt(\n    radix: number,\n    len?: number,\n    forceLen: boolean = false,\n    allowNumSeparator: boolean | \"bail\" = true,\n  ): number | null {\n    const { n, pos } = readInt(\n      this.input,\n      this.state.pos,\n      this.state.lineStart,\n      this.state.curLine,\n      radix,\n      len,\n      forceLen,\n      allowNumSeparator,\n      this.errorHandlers_readInt,\n      /* bailOnError */ false,\n    );\n    this.state.pos = pos;\n    return n;\n  }\n\n  readRadixNumber(radix: number): void {\n    const startLoc = this.state.curPosition();\n    let isBigInt = false;\n\n    this.state.pos += 2; // 0x\n    const val = this.readInt(radix);\n    if (val == null) {\n      this.raise(Errors.InvalidDigit, {\n        // Numeric literals can't have newlines, so this is safe to do.\n        at: createPositionWithColumnOffset(startLoc, 2),\n        radix,\n      });\n    }\n    const next = this.input.charCodeAt(this.state.pos);\n\n    if (next === charCodes.lowercaseN) {\n      ++this.state.pos;\n      isBigInt = true;\n    } else if (next === charCodes.lowercaseM) {\n      throw this.raise(Errors.InvalidDecimal, { at: startLoc });\n    }\n\n    if (isIdentifierStart(this.codePointAtPos(this.state.pos))) {\n      throw this.raise(Errors.NumberIdentifier, {\n        at: this.state.curPosition(),\n      });\n    }\n\n    if (isBigInt) {\n      const str = this.input\n        .slice(startLoc.index, this.state.pos)\n        .replace(/[_n]/g, \"\");\n      this.finishToken(tt.bigint, str);\n      return;\n    }\n\n    this.finishToken(tt.num, val);\n  }\n\n  // Read an integer, octal integer, or floating-point number.\n\n  readNumber(startsWithDot: boolean): void {\n    const start = this.state.pos;\n    const startLoc = this.state.curPosition();\n    let isFloat = false;\n    let isBigInt = false;\n    let isDecimal = false;\n    let hasExponent = false;\n    let isOctal = false;\n\n    if (!startsWithDot && this.readInt(10) === null) {\n      this.raise(Errors.InvalidNumber, { at: this.state.curPosition() });\n    }\n    const hasLeadingZero =\n      this.state.pos - start >= 2 &&\n      this.input.charCodeAt(start) === charCodes.digit0;\n\n    if (hasLeadingZero) {\n      const integer = this.input.slice(start, this.state.pos);\n      this.recordStrictModeErrors(Errors.StrictOctalLiteral, { at: startLoc });\n      if (!this.state.strict) {\n        // disallow numeric separators in non octal decimals and legacy octal likes\n        const underscorePos = integer.indexOf(\"_\");\n        if (underscorePos > 0) {\n          // Numeric literals can't have newlines, so this is safe to do.\n          this.raise(Errors.ZeroDigitNumericSeparator, {\n            at: createPositionWithColumnOffset(startLoc, underscorePos),\n          });\n        }\n      }\n      isOctal = hasLeadingZero && !/[89]/.test(integer);\n    }\n\n    let next = this.input.charCodeAt(this.state.pos);\n    if (next === charCodes.dot && !isOctal) {\n      ++this.state.pos;\n      this.readInt(10);\n      isFloat = true;\n      next = this.input.charCodeAt(this.state.pos);\n    }\n\n    if (\n      (next === charCodes.uppercaseE || next === charCodes.lowercaseE) &&\n      !isOctal\n    ) {\n      next = this.input.charCodeAt(++this.state.pos);\n      if (next === charCodes.plusSign || next === charCodes.dash) {\n        ++this.state.pos;\n      }\n      if (this.readInt(10) === null) {\n        this.raise(Errors.InvalidOrMissingExponent, { at: startLoc });\n      }\n      isFloat = true;\n      hasExponent = true;\n      next = this.input.charCodeAt(this.state.pos);\n    }\n\n    if (next === charCodes.lowercaseN) {\n      // disallow floats, legacy octal syntax and non octal decimals\n      // new style octal (\"0o\") is handled in this.readRadixNumber\n      if (isFloat || hasLeadingZero) {\n        this.raise(Errors.InvalidBigIntLiteral, { at: startLoc });\n      }\n      ++this.state.pos;\n      isBigInt = true;\n    }\n\n    if (next === charCodes.lowercaseM) {\n      this.expectPlugin(\"decimal\", this.state.curPosition());\n      if (hasExponent || hasLeadingZero) {\n        this.raise(Errors.InvalidDecimal, { at: startLoc });\n      }\n      ++this.state.pos;\n      isDecimal = true;\n    }\n\n    if (isIdentifierStart(this.codePointAtPos(this.state.pos))) {\n      throw this.raise(Errors.NumberIdentifier, {\n        at: this.state.curPosition(),\n      });\n    }\n\n    // remove \"_\" for numeric literal separator, and trailing `m` or `n`\n    const str = this.input.slice(start, this.state.pos).replace(/[_mn]/g, \"\");\n\n    if (isBigInt) {\n      this.finishToken(tt.bigint, str);\n      return;\n    }\n\n    if (isDecimal) {\n      this.finishToken(tt.decimal, str);\n      return;\n    }\n\n    const val = isOctal ? parseInt(str, 8) : parseFloat(str);\n    this.finishToken(tt.num, val);\n  }\n\n  // Read a string value, interpreting backslash-escapes.\n\n  readCodePoint(throwOnInvalid: boolean): number | null {\n    const { code, pos } = readCodePoint(\n      this.input,\n      this.state.pos,\n      this.state.lineStart,\n      this.state.curLine,\n      throwOnInvalid,\n      this.errorHandlers_readCodePoint,\n    );\n    this.state.pos = pos;\n    return code;\n  }\n\n  readString(quote: number): void {\n    const { str, pos, curLine, lineStart } = readStringContents(\n      quote === charCodes.quotationMark ? \"double\" : \"single\",\n      this.input,\n      this.state.pos + 1, // skip the quote\n      this.state.lineStart,\n      this.state.curLine,\n      this.errorHandlers_readStringContents_string,\n    );\n    this.state.pos = pos + 1; // skip the quote\n    this.state.lineStart = lineStart;\n    this.state.curLine = curLine;\n    this.finishToken(tt.string, str);\n  }\n\n  // Reads template continuation `}...`\n  readTemplateContinuation(): void {\n    if (!this.match(tt.braceR)) {\n      this.unexpected(null, tt.braceR);\n    }\n    // rewind pos to `}`\n    this.state.pos--;\n    this.readTemplateToken();\n  }\n\n  // Reads template string tokens.\n  readTemplateToken(): void {\n    const opening = this.input[this.state.pos];\n    const { str, firstInvalidLoc, pos, curLine, lineStart } =\n      readStringContents(\n        \"template\",\n        this.input,\n        this.state.pos + 1, // skip '`' or `}`\n        this.state.lineStart,\n        this.state.curLine,\n        this.errorHandlers_readStringContents_template,\n      );\n    this.state.pos = pos + 1; // skip '`' or `$`\n    this.state.lineStart = lineStart;\n    this.state.curLine = curLine;\n\n    if (firstInvalidLoc) {\n      this.state.firstInvalidTemplateEscapePos = new Position(\n        firstInvalidLoc.curLine,\n        firstInvalidLoc.pos - firstInvalidLoc.lineStart,\n        firstInvalidLoc.pos,\n      );\n    }\n\n    if (this.input.codePointAt(pos) === charCodes.graveAccent) {\n      this.finishToken(\n        tt.templateTail,\n        firstInvalidLoc ? null : opening + str + \"`\",\n      );\n    } else {\n      this.state.pos++; // skip '{'\n      this.finishToken(\n        tt.templateNonTail,\n        firstInvalidLoc ? null : opening + str + \"${\",\n      );\n    }\n  }\n\n  recordStrictModeErrors(\n    toParseError: DeferredStrictError,\n    { at }: { at: Position },\n  ) {\n    const index = at.index;\n\n    if (this.state.strict && !this.state.strictErrors.has(index)) {\n      this.raise(toParseError, { at });\n    } else {\n      this.state.strictErrors.set(index, [toParseError, at]);\n    }\n  }\n\n  // Read an identifier, and return it as a string. Sets `this.state.containsEsc`\n  // to whether the word contained a '\\u' escape.\n  //\n  // Incrementally adds only escaped chars, adding other chunks as-is\n  // as a micro-optimization.\n  //\n  // When `firstCode` is given, it assumes it is always an identifier start and\n  // will skip reading start position again\n\n  readWord1(firstCode?: number): string {\n    this.state.containsEsc = false;\n    let word = \"\";\n    const start = this.state.pos;\n    let chunkStart = this.state.pos;\n    if (firstCode !== undefined) {\n      this.state.pos += firstCode <= 0xffff ? 1 : 2;\n    }\n\n    while (this.state.pos < this.length) {\n      const ch = this.codePointAtPos(this.state.pos);\n      if (isIdentifierChar(ch)) {\n        this.state.pos += ch <= 0xffff ? 1 : 2;\n      } else if (ch === charCodes.backslash) {\n        this.state.containsEsc = true;\n\n        word += this.input.slice(chunkStart, this.state.pos);\n        const escStart = this.state.curPosition();\n        const identifierCheck =\n          this.state.pos === start ? isIdentifierStart : isIdentifierChar;\n\n        if (this.input.charCodeAt(++this.state.pos) !== charCodes.lowercaseU) {\n          this.raise(Errors.MissingUnicodeEscape, {\n            at: this.state.curPosition(),\n          });\n          chunkStart = this.state.pos - 1;\n          continue;\n        }\n\n        ++this.state.pos;\n        const esc = this.readCodePoint(true);\n        if (esc !== null) {\n          if (!identifierCheck(esc)) {\n            this.raise(Errors.EscapedCharNotAnIdentifier, { at: escStart });\n          }\n\n          word += String.fromCodePoint(esc);\n        }\n        chunkStart = this.state.pos;\n      } else {\n        break;\n      }\n    }\n    return word + this.input.slice(chunkStart, this.state.pos);\n  }\n\n  // Read an identifier or keyword token. Will check for reserved\n  // words when necessary.\n\n  readWord(firstCode?: number): void {\n    const word = this.readWord1(firstCode);\n    const type = keywordTypes.get(word);\n    if (type !== undefined) {\n      // We don't use word as state.value here because word is a dynamic string\n      // while token label is a shared constant string\n      this.finishToken(type, tokenLabelName(type));\n    } else {\n      this.finishToken(tt.name, word);\n    }\n  }\n\n  checkKeywordEscapes(): void {\n    const { type } = this.state;\n    if (tokenIsKeyword(type) && this.state.containsEsc) {\n      this.raise(Errors.InvalidEscapedReservedWord, {\n        at: this.state.startLoc,\n        reservedWord: tokenLabelName(type),\n      });\n    }\n  }\n\n  /**\n   * Raise a `ParseError` given the appropriate properties. If passed a\n   * `Position` for the `at` property, raises the `ParseError` at that location.\n   * Otherwise, if passed a `Node`, raises the `ParseError` at the start\n   * location of that `Node`.\n   *\n   * If `errorRecovery` is `true`, the error is pushed to the errors array and\n   * returned. If `errorRecovery` is `false`, the error is instead thrown.\n   */\n  raise<ErrorDetails>(\n    toParseError: ParseErrorConstructor<ErrorDetails>,\n    raiseProperties: RaiseProperties<ErrorDetails>,\n  ): ParseError<ErrorDetails> {\n    const { at, ...details } = raiseProperties;\n    const loc = at instanceof Position ? at : at.loc.start;\n    // @ts-expect-error: refine details typing\n    const error = toParseError({ loc, details });\n\n    if (!this.options.errorRecovery) throw error;\n    if (!this.isLookahead) this.state.errors.push(error);\n\n    return error;\n  }\n\n  /**\n   * If `errorRecovery` is `false`, this method behaves identically to `raise`.\n   * If `errorRecovery` is `true`, this method will first see if there is\n   * already an error stored at the same `Position`, and replaces it with the\n   * one generated here.\n   */\n  raiseOverwrite<ErrorDetails>(\n    toParseError: ParseErrorConstructor<ErrorDetails>,\n    raiseProperties: RaiseProperties<ErrorDetails>,\n  ): ParseError<ErrorDetails> | never {\n    const { at, ...details } = raiseProperties;\n    const loc = at instanceof Position ? at : at.loc.start;\n    const pos = loc.index;\n    const errors = this.state.errors;\n\n    for (let i = errors.length - 1; i >= 0; i--) {\n      const error = errors[i];\n      if (error.loc.index === pos) {\n        // @ts-expect-error: refine details typing\n        return (errors[i] = toParseError({ loc, details }));\n      }\n      if (error.loc.index < pos) break;\n    }\n\n    return this.raise(toParseError, raiseProperties);\n  }\n\n  // updateContext is used by the jsx plugin\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  updateContext(prevType: TokenType): void {}\n\n  // Raise an unexpected token error. Can take the expected token type.\n  unexpected(loc?: Position | null, type?: TokenType): void {\n    throw this.raise(Errors.UnexpectedToken, {\n      expected: type ? tokenLabelName(type) : null,\n      at: loc != null ? loc : this.state.startLoc,\n    });\n  }\n\n  expectPlugin(pluginName: Plugin, loc?: Position): true {\n    if (this.hasPlugin(pluginName)) {\n      return true;\n    }\n\n    throw this.raise(Errors.MissingPlugin, {\n      at: loc != null ? loc : this.state.startLoc,\n      missingPlugin: [pluginName],\n    });\n  }\n\n  expectOnePlugin(pluginNames: Plugin[]): void {\n    if (!pluginNames.some(name => this.hasPlugin(name))) {\n      throw this.raise(Errors.MissingOneOfPlugins, {\n        at: this.state.startLoc,\n        missingPlugin: pluginNames,\n      });\n    }\n  }\n\n  errorBuilder(error: ParseErrorConstructor<{}>) {\n    return (pos: number, lineStart: number, curLine: number) => {\n      this.raise(error, {\n        at: buildPosition(pos, lineStart, curLine),\n      });\n    };\n  }\n\n  errorHandlers_readInt: IntErrorHandlers = {\n    invalidDigit: (pos, lineStart, curLine, radix) => {\n      if (!this.options.errorRecovery) return false;\n\n      this.raise(Errors.InvalidDigit, {\n        at: buildPosition(pos, lineStart, curLine),\n        radix,\n      });\n      // Continue parsing the number as if there was no invalid digit.\n      return true;\n    },\n    numericSeparatorInEscapeSequence: this.errorBuilder(\n      Errors.NumericSeparatorInEscapeSequence,\n    ),\n    unexpectedNumericSeparator: this.errorBuilder(\n      Errors.UnexpectedNumericSeparator,\n    ),\n  };\n\n  errorHandlers_readCodePoint: CodePointErrorHandlers = {\n    ...this.errorHandlers_readInt,\n    invalidEscapeSequence: this.errorBuilder(Errors.InvalidEscapeSequence),\n    invalidCodePoint: this.errorBuilder(Errors.InvalidCodePoint),\n  };\n\n  errorHandlers_readStringContents_string: StringContentsErrorHandlers = {\n    ...this.errorHandlers_readCodePoint,\n    strictNumericEscape: (pos, lineStart, curLine) => {\n      this.recordStrictModeErrors(Errors.StrictNumericEscape, {\n        at: buildPosition(pos, lineStart, curLine),\n      });\n    },\n    unterminated: (pos, lineStart, curLine) => {\n      throw this.raise(Errors.UnterminatedString, {\n        // Report the error at the string quote\n        at: buildPosition(pos - 1, lineStart, curLine),\n      });\n    },\n  };\n\n  errorHandlers_readStringContents_template: StringContentsErrorHandlers = {\n    ...this.errorHandlers_readCodePoint,\n    strictNumericEscape: this.errorBuilder(Errors.StrictNumericEscape),\n    unterminated: (pos, lineStart, curLine) => {\n      throw this.raise(Errors.UnterminatedTemplate, {\n        at: buildPosition(pos, lineStart, curLine),\n      });\n    },\n  };\n}\n"],"mappings":"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"}���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������lib/tokenizer/state.js������������������������������������������������������������������������������0000644�����������������00000004330�15120211212�0010765 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;
var _location = require("../util/location");
var _context = require("./context");
var _types = require("./types");
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.inDisallowConditionalTypesContext = false;
    this.topicContext = {
      maxNumOfResolvableTopics: 0,
      maxTopicIndex: null
    };
    this.soloAwait = false;
    this.inFSharpPipelineDirectBody = false;
    this.labels = [];
    this.comments = [];
    this.commentStack = [];
    this.pos = 0;
    this.type = 137;
    this.value = null;
    this.start = 0;
    this.end = 0;
    this.lastTokEndLoc = null;
    this.lastTokStartLoc = null;
    this.lastTokStart = 0;
    this.context = [_context.types.brace];
    this.canStartJSXElement = true;
    this.containsEsc = false;
    this.firstInvalidTemplateEscapePos = null;
    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 _location.Position(startLine, startColumn, 0);
  }
  curPosition() {
    return new _location.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;
  }
}
exports.default = State;

//# sourceMappingURL=state.js.map
��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������lib/tokenizer/state.js.map��������������������������������������������������������������������������0000644�����������������00000022006�15120211212�0011541 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������{"version":3,"names":["_location","require","_context","_types","State","constructor","strict","curLine","lineStart","startLoc","endLoc","errors","potentialArrowAt","noArrowAt","noArrowParamsConversionAt","maybeInArrowParameters","inType","noAnonFunctionType","hasFlowComment","isAmbientContext","inAbstractClass","inDisallowConditionalTypesContext","topicContext","maxNumOfResolvableTopics","maxTopicIndex","soloAwait","inFSharpPipelineDirectBody","labels","comments","commentStack","pos","type","value","start","end","lastTokEndLoc","lastTokStartLoc","lastTokStart","context","ct","brace","canStartJSXElement","containsEsc","firstInvalidTemplateEscapePos","strictErrors","Map","tokensLength","init","strictMode","sourceType","startLine","startColumn","Position","curPosition","clone","skipArrays","state","keys","Object","i","length","key","val","Array","isArray","slice","exports","default"],"sources":["../../src/tokenizer/state.ts"],"sourcesContent":["import type { Options } from \"../options\";\nimport type * 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 { Errors } from \"../parse-error\";\nimport type { ParseError } from \"../parse-error\";\n\nexport type DeferredStrictError =\n  | typeof Errors.StrictNumericEscape\n  | typeof Errors.StrictOctalLiteral;\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  // 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: ParseError<any>[] = [];\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  inDisallowConditionalTypesContext: 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\" | undefined | null;\n    name?: string | null;\n    statementStart?: number;\n  }> = [];\n\n  // Comment store for Program.comments\n  comments: Array<N.Comment> = [];\n\n  // Comment attachment store\n  commentStack: Array<CommentWhitespace> = [];\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  // this is initialized when generating the second token.\n  lastTokEndLoc: Position = null;\n  // 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<TokContext> = [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  // Used to track invalid escape sequences in template literals,\n  // that must be reported if the template is not tagged.\n  firstInvalidTemplateEscapePos: null | Position = null;\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<number, [DeferredStrictError, Position]> = 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) as (keyof State)[];\n    for (let i = 0, length = keys.length; i < length; i++) {\n      const key = keys[i];\n      let val = this[key];\n\n      if (!skipArrays && Array.isArray(val)) {\n        val = val.slice();\n      }\n\n      // @ts-expect-error val must conform to S[key]\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  context: TokContext[];\n  startLoc: Position;\n  lastTokEndLoc: Position;\n  curLine: number;\n  lineStart: number;\n  curPosition: () => Position;\n  /* Used only in readToken_mult_modulo */\n  inType: boolean;\n  // These boolean properties are not initialized in createLookaheadState()\n  // instead they will only be set by the tokenizer\n  containsEsc?: boolean;\n};\n"],"mappings":"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"}��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������lib/tokenizer/types.js������������������������������������������������������������������������������0000644�����������������00000033740�15120211212�0011020 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.ExportedTokenType = void 0;
exports.getExportedToken = getExportedToken;
exports.isTokenType = isTokenType;
exports.keywords = void 0;
exports.tokenCanStartExpression = tokenCanStartExpression;
exports.tokenComesBeforeExpression = tokenComesBeforeExpression;
exports.tokenIsAssignment = tokenIsAssignment;
exports.tokenIsBinaryOperator = tokenIsBinaryOperator;
exports.tokenIsFlowInterfaceOrTypeOrOpaque = tokenIsFlowInterfaceOrTypeOrOpaque;
exports.tokenIsIdentifier = tokenIsIdentifier;
exports.tokenIsKeyword = tokenIsKeyword;
exports.tokenIsKeywordOrIdentifier = tokenIsKeywordOrIdentifier;
exports.tokenIsLiteralPropertyName = tokenIsLiteralPropertyName;
exports.tokenIsLoop = tokenIsLoop;
exports.tokenIsOperator = tokenIsOperator;
exports.tokenIsPostfix = tokenIsPostfix;
exports.tokenIsPrefix = tokenIsPrefix;
exports.tokenIsRightAssociative = tokenIsRightAssociative;
exports.tokenIsTSDeclarationStart = tokenIsTSDeclarationStart;
exports.tokenIsTSTypeOperator = tokenIsTSTypeOperator;
exports.tokenIsTemplate = tokenIsTemplate;
exports.tokenKeywordOrIdentifierIsKeyword = tokenKeywordOrIdentifierIsKeyword;
exports.tokenLabelName = tokenLabelName;
exports.tokenOperatorPrecedence = tokenOperatorPrecedence;
exports.tt = exports.tokenTypes = void 0;
var _context = require("./context");
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;
    }
  }
}
exports.ExportedTokenType = ExportedTokenType;
const keywords = new Map();
exports.keywords = keywords;
function createKeyword(name, options = {}) {
  options.keyword = name;
  const token = createToken(name, options);
  keywords.set(name, token);
  return token;
}
function createBinop(name, binop) {
  return createToken(name, {
    beforeExpr,
    binop
  });
}
let tokenTypeCounter = -1;
const tokenTypes = [];
exports.tokenTypes = 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.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("}"),
  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
  }),
  _using: createKeywordLike("using", {
    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
  }),
  _satisfies: createKeywordLike("satisfies", {
    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
  })
};
exports.tt = tt;
function tokenIsIdentifier(token) {
  return token >= 93 && token <= 130;
}
function tokenKeywordOrIdentifierIsKeyword(token) {
  return token <= 92;
}
function tokenIsKeywordOrIdentifier(token) {
  return token >= 58 && token <= 130;
}
function tokenIsLiteralPropertyName(token) {
  return token >= 58 && token <= 134;
}
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 >= 127 && token <= 129;
}
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 >= 119 && token <= 121;
}
function tokenIsTSDeclarationStart(token) {
  return token >= 122 && token <= 128;
}
function tokenLabelName(token) {
  return tokenLabels[token];
}
function tokenOperatorPrecedence(token) {
  return tokenBinops[token];
}
function tokenIsBinaryOperator(token) {
  return tokenBinops[token] !== -1;
}
function tokenIsRightAssociative(token) {
  return token === 57;
}
function tokenIsTemplate(token) {
  return token >= 24 && token <= 25;
}
function getExportedToken(token) {
  return tokenTypes[token];
}
function isTokenType(obj) {
  return typeof obj === "number";
}
{
  tokenTypes[8].updateContext = context => {
    context.pop();
  };
  tokenTypes[5].updateContext = tokenTypes[7].updateContext = tokenTypes[23].updateContext = context => {
    context.push(_context.types.brace);
  };
  tokenTypes[22].updateContext = context => {
    if (context[context.length - 1] === _context.types.template) {
      context.pop();
    } else {
      context.push(_context.types.template);
    }
  };
  tokenTypes[140].updateContext = context => {
    context.push(_context.types.j_expr, _context.types.j_oTag);
  };
}

//# sourceMappingURL=types.js.map
��������������������������������lib/tokenizer/types.js.map��������������������������������������������������������������������������0000644�����������������00000102525�15120211212�0011572 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������{"version":3,"names":["_context","require","beforeExpr","startsExpr","isLoop","isAssign","prefix","postfix","ExportedTokenType","constructor","label","conf","keyword","rightAssociative","binop","updateContext","exports","keywords","Map","createKeyword","name","options","token","createToken","set","createBinop","tokenTypeCounter","tokenTypes","tokenLabels","tokenBinops","tokenBeforeExprs","tokenStartsExprs","tokenPrefixes","_options$binop","_options$beforeExpr","_options$startsExpr","_options$prefix","push","createKeywordLike","_options$binop2","_options$beforeExpr2","_options$startsExpr2","_options$prefix2","tt","bracketL","bracketHashL","bracketBarL","bracketR","bracketBarR","braceL","braceBarL","braceHashL","braceR","braceBarR","parenL","parenR","comma","semi","colon","doubleColon","dot","question","questionDot","arrow","template","ellipsis","backQuote","dollarBraceL","templateTail","templateNonTail","at","hash","interpreterDirective","eq","assign","slashAssign","xorAssign","moduloAssign","incDec","bang","tilde","doubleCaret","doubleAt","pipeline","nullishCoalescing","logicalOR","logicalAND","bitwiseOR","bitwiseXOR","bitwiseAND","equality","lt","gt","relational","bitShift","bitShiftL","bitShiftR","plusMin","modulo","star","slash","exponent","_in","_instanceof","_break","_case","_catch","_continue","_debugger","_default","_else","_finally","_function","_if","_return","_switch","_throw","_try","_var","_const","_with","_new","_this","_super","_class","_extends","_export","_import","_null","_true","_false","_typeof","_void","_delete","_do","_for","_while","_as","_assert","_async","_await","_from","_get","_let","_meta","_of","_sent","_set","_static","_using","_yield","_asserts","_checks","_exports","_global","_implements","_intrinsic","_infer","_is","_mixins","_proto","_require","_satisfies","_keyof","_readonly","_unique","_abstract","_declare","_enum","_module","_namespace","_interface","_type","_opaque","string","num","bigint","decimal","regexp","privateName","eof","jsxName","jsxText","jsxTagStart","jsxTagEnd","placeholder","tokenIsIdentifier","tokenKeywordOrIdentifierIsKeyword","tokenIsKeywordOrIdentifier","tokenIsLiteralPropertyName","tokenComesBeforeExpression","tokenCanStartExpression","tokenIsAssignment","tokenIsFlowInterfaceOrTypeOrOpaque","tokenIsLoop","tokenIsKeyword","tokenIsOperator","tokenIsPostfix","tokenIsPrefix","tokenIsTSTypeOperator","tokenIsTSDeclarationStart","tokenLabelName","tokenOperatorPrecedence","tokenIsBinaryOperator","tokenIsRightAssociative","tokenIsTemplate","getExportedToken","isTokenType","obj","context","pop","tc","brace","length","j_expr","j_oTag"],"sources":["../../src/tokenizer/types.ts"],"sourcesContent":["import { 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 (<name>); 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 | null;\n};\n\n// Internally the tokenizer stores token as a number\nexport 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 | undefined | null;\n  beforeExpr: boolean;\n  startsExpr: boolean;\n  rightAssociative: boolean;\n  isLoop: boolean;\n  isAssign: boolean;\n  prefix: boolean;\n  postfix: boolean;\n  binop: number | undefined | null;\n  // todo(Babel 8): remove updateContext from exposed token layout\n  declare updateContext:\n    | ((context: Array<TokContext>) => void)\n    | undefined\n    | null;\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<string, TokenType>();\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 type InternalTokenTypes = typeof tt;\n\nexport const tt = {\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(\"}\"),\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  _using: createKeywordLike(\"using\", { 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  _satisfies: createKeywordLike(\"satisfies\", { 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} as const;\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 tokenIsBinaryOperator(token: TokenType): boolean {\n  return tokenBinops[token] !== -1;\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"],"mappings":"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"}���������������������������������������������������������������������������������������������������������������������������������������������������������������������������lib/util/class-scope.js�����������������������������������������������������������������������������0000644�����������������00000005255�15120211212�0011033 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = exports.ClassScope = void 0;
var _scopeflags = require("./scopeflags");
var _parseError = require("../parse-error");
class ClassScope {
  constructor() {
    this.privateNames = new Set();
    this.loneAccessors = new Map();
    this.undefinedPrivateNames = new Map();
  }
}
exports.ClassScope = ClassScope;
class ClassScopeHandler {
  constructor(parser) {
    this.parser = void 0;
    this.stack = [];
    this.undefinedPrivateNames = new Map();
    this.parser = parser;
  }
  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.parser.raise(_parseError.Errors.InvalidPrivateFieldResolution, {
          at: loc,
          identifierName: name
        });
      }
    }
  }
  declarePrivateName(name, elementType, loc) {
    const {
      privateNames,
      loneAccessors,
      undefinedPrivateNames
    } = this.current();
    let redefined = privateNames.has(name);
    if (elementType & _scopeflags.CLASS_ELEMENT_KIND_ACCESSOR) {
      const accessor = redefined && loneAccessors.get(name);
      if (accessor) {
        const oldStatic = accessor & _scopeflags.CLASS_ELEMENT_FLAG_STATIC;
        const newStatic = elementType & _scopeflags.CLASS_ELEMENT_FLAG_STATIC;
        const oldKind = accessor & _scopeflags.CLASS_ELEMENT_KIND_ACCESSOR;
        const newKind = elementType & _scopeflags.CLASS_ELEMENT_KIND_ACCESSOR;
        redefined = oldKind === newKind || oldStatic !== newStatic;
        if (!redefined) loneAccessors.delete(name);
      } else if (!redefined) {
        loneAccessors.set(name, elementType);
      }
    }
    if (redefined) {
      this.parser.raise(_parseError.Errors.PrivateNameRedeclaration, {
        at: loc,
        identifierName: 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.parser.raise(_parseError.Errors.InvalidPrivateFieldResolution, {
        at: loc,
        identifierName: name
      });
    }
  }
}
exports.default = ClassScopeHandler;

//# sourceMappingURL=class-scope.js.map
���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������lib/util/class-scope.js.map�������������������������������������������������������������������������0000644�����������������00000015157�15120211212�0011611 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������{"version":3,"names":["_scopeflags","require","_parseError","ClassScope","constructor","privateNames","Set","loneAccessors","Map","undefinedPrivateNames","exports","ClassScopeHandler","parser","stack","current","length","enter","push","exit","oldClassScope","pop","name","loc","Array","from","has","set","raise","Errors","InvalidPrivateFieldResolution","at","identifierName","declarePrivateName","elementType","redefined","CLASS_ELEMENT_KIND_ACCESSOR","accessor","get","oldStatic","CLASS_ELEMENT_FLAG_STATIC","newStatic","oldKind","newKind","delete","PrivateNameRedeclaration","add","usePrivateName","classScope","default"],"sources":["../../src/util/class-scope.ts"],"sourcesContent":["import {\n  CLASS_ELEMENT_KIND_ACCESSOR,\n  CLASS_ELEMENT_FLAG_STATIC,\n  type ClassElementTypes,\n} from \"./scopeflags\";\nimport type { Position } from \"./location\";\nimport { Errors } from \"../parse-error\";\nimport type Tokenizer from \"../tokenizer\";\n\nexport class ClassScope {\n  // A list of private named declared in the current class\n  privateNames: Set<string> = new Set();\n\n  // A list of private getters of setters without their counterpart\n  loneAccessors: Map<string, ClassElementTypes> = new Map();\n\n  // A list of private names used before being defined, mapping to\n  // their position.\n  undefinedPrivateNames: Map<string, Position> = new Map();\n}\n\nexport default class ClassScopeHandler {\n  parser: Tokenizer;\n  stack: Array<ClassScope> = [];\n  undefinedPrivateNames: Map<string, Position> = new Map();\n\n  constructor(parser: Tokenizer) {\n    this.parser = parser;\n  }\n\n  current(): ClassScope {\n    return this.stack[this.stack.length - 1];\n  }\n\n  enter() {\n    this.stack.push(new ClassScope());\n  }\n\n  exit() {\n    const oldClassScope = this.stack.pop();\n\n    // Migrate the usage of not yet defined private names to the outer\n    // class scope, or raise an error if we reached the top-level scope.\n\n    const current = this.current();\n\n    // Array.from is needed because this is compiled to an array-like for loop\n    for (const [name, loc] of Array.from(oldClassScope.undefinedPrivateNames)) {\n      if (current) {\n        if (!current.undefinedPrivateNames.has(name)) {\n          current.undefinedPrivateNames.set(name, loc);\n        }\n      } else {\n        this.parser.raise(Errors.InvalidPrivateFieldResolution, {\n          at: loc,\n          identifierName: name,\n        });\n      }\n    }\n  }\n\n  declarePrivateName(\n    name: string,\n    elementType: ClassElementTypes,\n    loc: Position,\n  ) {\n    const { privateNames, loneAccessors, undefinedPrivateNames } =\n      this.current();\n    let redefined = privateNames.has(name);\n\n    if (elementType & CLASS_ELEMENT_KIND_ACCESSOR) {\n      const accessor = redefined && loneAccessors.get(name);\n      if (accessor) {\n        const oldStatic = accessor & CLASS_ELEMENT_FLAG_STATIC;\n        const newStatic = elementType & CLASS_ELEMENT_FLAG_STATIC;\n\n        const oldKind = accessor & CLASS_ELEMENT_KIND_ACCESSOR;\n        const newKind = elementType & CLASS_ELEMENT_KIND_ACCESSOR;\n\n        // The private name can be duplicated only if it is used by\n        // two accessors with different kind (get and set), and if\n        // they have the same placement (static or not).\n        redefined = oldKind === newKind || oldStatic !== newStatic;\n\n        if (!redefined) loneAccessors.delete(name);\n      } else if (!redefined) {\n        loneAccessors.set(name, elementType);\n      }\n    }\n\n    if (redefined) {\n      this.parser.raise(Errors.PrivateNameRedeclaration, {\n        at: loc,\n        identifierName: name,\n      });\n    }\n\n    privateNames.add(name);\n    undefinedPrivateNames.delete(name);\n  }\n\n  usePrivateName(name: string, loc: Position) {\n    let classScope;\n    for (classScope of this.stack) {\n      if (classScope.privateNames.has(name)) return;\n    }\n\n    if (classScope) {\n      classScope.undefinedPrivateNames.set(name, loc);\n    } else {\n      // top-level\n      this.parser.raise(Errors.InvalidPrivateFieldResolution, {\n        at: loc,\n        identifierName: name,\n      });\n    }\n  }\n}\n"],"mappings":"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"}�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������lib/util/expression-scope.js������������������������������������������������������������������������0000644�����������������00000007437�15120211212�0012131 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;
exports.newArrowHeadScope = newArrowHeadScope;
exports.newAsyncArrowScope = newAsyncArrowScope;
exports.newExpressionScope = newExpressionScope;
exports.newParameterDeclarationScope = newParameterDeclarationScope;
var _parseError = require("../parse-error");
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.declarationErrors = new Map();
  }
  recordDeclarationError(ParsingErrorClass, {
    at
  }) {
    const index = at.index;
    this.declarationErrors.set(index, [ParsingErrorClass, at]);
  }
  clearDeclarationError(index) {
    this.declarationErrors.delete(index);
  }
  iterateErrors(iterator) {
    this.declarationErrors.forEach(iterator);
  }
}
class ExpressionScopeHandler {
  constructor(parser) {
    this.parser = void 0;
    this.stack = [new ExpressionScope()];
    this.parser = parser;
  }
  enter(scope) {
    this.stack.push(scope);
  }
  exit() {
    this.stack.pop();
  }
  recordParameterInitializerError(toParseError, {
    at: node
  }) {
    const origin = {
      at: node.loc.start
    };
    const {
      stack
    } = this;
    let i = stack.length - 1;
    let scope = stack[i];
    while (!scope.isCertainlyParameterDeclaration()) {
      if (scope.canBeArrowParameterDeclaration()) {
        scope.recordDeclarationError(toParseError, origin);
      } else {
        return;
      }
      scope = stack[--i];
    }
    this.parser.raise(toParseError, origin);
  }
  recordArrowParameterBindingError(error, {
    at: node
  }) {
    const {
      stack
    } = this;
    const scope = stack[stack.length - 1];
    const origin = {
      at: node.loc.start
    };
    if (scope.isCertainlyParameterDeclaration()) {
      this.parser.raise(error, origin);
    } else if (scope.canBeArrowParameterDeclaration()) {
      scope.recordDeclarationError(error, origin);
    } else {
      return;
    }
  }
  recordAsyncArrowParametersError({
    at
  }) {
    const {
      stack
    } = this;
    let i = stack.length - 1;
    let scope = stack[i];
    while (scope.canBeArrowParameterDeclaration()) {
      if (scope.type === kMaybeAsyncArrowParameterDeclaration) {
        scope.recordDeclarationError(_parseError.Errors.AwaitBindingIdentifier, {
          at
        });
      }
      scope = stack[--i];
    }
  }
  validateAsPattern() {
    const {
      stack
    } = this;
    const currentScope = stack[stack.length - 1];
    if (!currentScope.canBeArrowParameterDeclaration()) return;
    currentScope.iterateErrors(([toParseError, loc]) => {
      this.parser.raise(toParseError, {
        at: loc
      });
      let i = stack.length - 2;
      let scope = stack[i];
      while (scope.canBeArrowParameterDeclaration()) {
        scope.clearDeclarationError(loc.index);
        scope = stack[--i];
      }
    });
  }
}
exports.default = ExpressionScopeHandler;
function newParameterDeclarationScope() {
  return new ExpressionScope(kParameterDeclaration);
}
function newArrowHeadScope() {
  return new ArrowHeadParsingScope(kMaybeArrowParameterDeclaration);
}
function newAsyncArrowScope() {
  return new ArrowHeadParsingScope(kMaybeAsyncArrowParameterDeclaration);
}
function newExpressionScope() {
  return new ExpressionScope();
}

//# sourceMappingURL=expression-scope.js.map
���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������lib/util/expression-scope.js.map��������������������������������������������������������������������0000644�����������������00000031461�15120211212�0012677 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������{"version":3,"names":["_parseError","require","kExpression","kMaybeArrowParameterDeclaration","kMaybeAsyncArrowParameterDeclaration","kParameterDeclaration","ExpressionScope","constructor","type","canBeArrowParameterDeclaration","isCertainlyParameterDeclaration","ArrowHeadParsingScope","declarationErrors","Map","recordDeclarationError","ParsingErrorClass","at","index","set","clearDeclarationError","delete","iterateErrors","iterator","forEach","ExpressionScopeHandler","parser","stack","enter","scope","push","exit","pop","recordParameterInitializerError","toParseError","node","origin","loc","start","i","length","raise","recordArrowParameterBindingError","error","recordAsyncArrowParametersError","Errors","AwaitBindingIdentifier","validateAsPattern","currentScope","exports","default","newParameterDeclarationScope","newArrowHeadScope","newAsyncArrowScope","newExpressionScope"],"sources":["../../src/util/expression-scope.ts"],"sourcesContent":["import { Errors, type ParseErrorConstructor } from \"../parse-error\";\nimport type { Position } from \"./location\";\nimport type { Node } from \"../types\";\nimport type Tokenizer from \"../tokenizer\";\n\n/**\n * @module util/expression-scope\n\nExpressionScope is used to track declaration errors in these ambiguous patterns:\n\n- CoverParenthesizedExpressionAndArrowParameterList\n  e.g. we don't know if `({ x })` is an parenthesized expression or an\n  arrow function parameters until we see an `=>` after `)`.\n\n- CoverCallExpressionAndAsyncArrowHead\n  e.g. we don't know if `async({ x })` is a call expression or an async arrow\n  function parameters until we see an `=>` after `)`\n\nThe following declaration errors (@see parser-errors/standard) will be recorded in\nsome expression scopes and thrown later when we know what the ambiguous pattern is\n\n- AwaitBindingIdentifier\n- AwaitExpressionFormalParameter\n- YieldInParameter\n- InvalidParenthesizedAssignment when parenthesized is an identifier\n\nThere are four different expression scope\n- Expression\n  A general scope that represents program / function body / static block. No errors\n  will be recorded nor thrown in this scope.\n\n- MaybeArrowParameterDeclaration\n  A scope that represents ambiguous arrow head e.g. `(x)`. Errors will be recorded\n  alongside parent scopes and thrown when `ExpressionScopeHandler#validateAsPattern`\n  is called.\n\n- MaybeAsyncArrowParameterDeclaration\n  A scope that represents ambiguous async arrow head e.g. `async(x)`. Errors will\n  be recorded alongside parent scopes and thrown when\n  `ExpressionScopeHandler#validateAsPattern` is called.\n\n- ParameterDeclaration\n  A scope that represents unambiguous function parameters `function(x)`. Errors\n  recorded in this scope will be thrown immediately. No errors will be recorded in\n  this scope.\n\n// @see {@link https://docs.google.com/document/d/1FAvEp9EUK-G8kHfDIEo_385Hs2SUBCYbJ5H-NnLvq8M|V8 Expression Scope design docs}\n */\n\nconst kExpression = 0,\n  kMaybeArrowParameterDeclaration = 1,\n  kMaybeAsyncArrowParameterDeclaration = 2,\n  kParameterDeclaration = 3;\n\ntype ExpressionScopeType = 0 | 1 | 2 | 3;\n\nclass ExpressionScope {\n  type: ExpressionScopeType;\n\n  constructor(type: ExpressionScopeType = kExpression) {\n    this.type = type;\n  }\n\n  canBeArrowParameterDeclaration(): this is ArrowHeadParsingScope {\n    return (\n      this.type === kMaybeAsyncArrowParameterDeclaration ||\n      this.type === kMaybeArrowParameterDeclaration\n    );\n  }\n\n  isCertainlyParameterDeclaration() {\n    return this.type === kParameterDeclaration;\n  }\n}\n\ntype ArrowHeadParsingParameterInitializerError =\n  | typeof Errors.AwaitExpressionFormalParameter\n  | typeof Errors.YieldInParameter;\ntype ArrowHeadParsingDeclarationError =\n  | ArrowHeadParsingParameterInitializerError\n  | typeof Errors.InvalidParenthesizedAssignment\n  | typeof Errors.AwaitBindingIdentifier;\n\nclass ArrowHeadParsingScope extends ExpressionScope {\n  declarationErrors: Map<number, [ParseErrorConstructor<{}>, Position]> =\n    new Map();\n  constructor(type: 1 | 2) {\n    super(type);\n  }\n  recordDeclarationError(\n    ParsingErrorClass: ParseErrorConstructor<{}>,\n    {\n      at,\n    }: {\n      at: Position;\n    },\n  ) {\n    const index = at.index;\n\n    this.declarationErrors.set(index, [ParsingErrorClass, at]);\n  }\n  clearDeclarationError(index: number) {\n    this.declarationErrors.delete(index);\n  }\n  iterateErrors(\n    iterator: (a: [ArrowHeadParsingDeclarationError, Position]) => void,\n  ) {\n    this.declarationErrors.forEach(iterator);\n  }\n}\n\nexport default class ExpressionScopeHandler {\n  parser: Tokenizer;\n  stack: Array<ExpressionScope> = [new ExpressionScope()];\n\n  constructor(parser: Tokenizer) {\n    this.parser = parser;\n  }\n  enter(scope: ExpressionScope) {\n    this.stack.push(scope);\n  }\n\n  exit() {\n    this.stack.pop();\n  }\n\n  /**\n   * Record likely parameter initializer errors\n   *\n   * When current scope is a ParameterDeclaration, the error will be thrown immediately,\n   * otherwise it will be recorded to any ancestry MaybeArrowParameterDeclaration and\n   * MaybeAsyncArrowParameterDeclaration scope until an Expression scope is seen.\n   */\n  recordParameterInitializerError(\n    toParseError: ArrowHeadParsingParameterInitializerError,\n    {\n      at: node,\n    }: {\n      at: Node;\n    },\n  ): void {\n    const origin = { at: node.loc.start };\n    const { stack } = this;\n    let i = stack.length - 1;\n    let scope: ExpressionScope = stack[i];\n    while (!scope.isCertainlyParameterDeclaration()) {\n      if (scope.canBeArrowParameterDeclaration()) {\n        scope.recordDeclarationError(toParseError, origin);\n      } else {\n        /*:: invariant(scope.type == kExpression) */\n        // Type-Expression is the boundary where initializer error can populate to\n        return;\n      }\n      scope = stack[--i];\n    }\n    this.parser.raise(toParseError, origin);\n  }\n\n  /**\n   * Record errors that must be thrown if the current pattern ends up being an arrow\n   * function parameter. This is used to record parenthesized identifiers, and to record\n   * \"a as T\" and \"<T> a\" type assertions when parsing typescript.\n   *\n   * A parenthesized identifier (or type assertion) in LHS can be ambiguous because the assignment\n   * can be transformed to an assignable later, but not vice versa:\n   * For example, in `([(a) = []] = []) => {}`, we think `(a) = []` is an LHS in `[(a) = []]`,\n   * an LHS within `[(a) = []] = []`. However the LHS chain is then transformed by toAssignable,\n   * and we should throw assignment `(a)`, which is only valid in LHS. Hence we record the\n   * location of parenthesized `(a)` to current scope if it is one of MaybeArrowParameterDeclaration\n   * and MaybeAsyncArrowParameterDeclaration\n   *\n   * Unlike `recordParameterInitializerError`, we don't record to ancestry scope because we\n   * validate arrow head parsing scope before exit, and then the LHS will be unambiguous:\n   * For example, in `( x = ( [(a) = []] = [] ) ) => {}`, we should not record `(a)` in `( x = ... ) =>`\n   * arrow scope because when we finish parsing `( [(a) = []] = [] )`, it is an unambiguous assignment\n   * expression and can not be cast to pattern\n   */\n  recordArrowParameterBindingError(\n    error: ParseErrorConstructor<{}>,\n    {\n      at: node,\n    }: {\n      at: Node;\n    },\n  ): void {\n    const { stack } = this;\n    const scope: ExpressionScope = stack[stack.length - 1];\n    const origin = { at: node.loc.start };\n    if (scope.isCertainlyParameterDeclaration()) {\n      this.parser.raise(error, origin);\n    } else if (scope.canBeArrowParameterDeclaration()) {\n      scope.recordDeclarationError(error, origin);\n    } else {\n      return;\n    }\n  }\n\n  /**\n   * Record likely async arrow parameter errors\n   *\n   * Errors will be recorded to any ancestry MaybeAsyncArrowParameterDeclaration\n   * scope until an Expression scope is seen.\n   */\n  recordAsyncArrowParametersError({ at }: { at: Position }): void {\n    const { stack } = this;\n    let i = stack.length - 1;\n    let scope: ExpressionScope = stack[i];\n    while (scope.canBeArrowParameterDeclaration()) {\n      if (scope.type === kMaybeAsyncArrowParameterDeclaration) {\n        scope.recordDeclarationError(Errors.AwaitBindingIdentifier, { at });\n      }\n      scope = stack[--i];\n    }\n  }\n\n  validateAsPattern(): void {\n    const { stack } = this;\n    const currentScope = stack[stack.length - 1];\n    if (!currentScope.canBeArrowParameterDeclaration()) return;\n    currentScope.iterateErrors(([toParseError, loc]) => {\n      this.parser.raise(toParseError, { at: loc });\n      // iterate from parent scope\n      let i = stack.length - 2;\n      let scope = stack[i];\n      while (scope.canBeArrowParameterDeclaration()) {\n        scope.clearDeclarationError(loc.index);\n        scope = stack[--i];\n      }\n    });\n  }\n}\n\nexport function newParameterDeclarationScope() {\n  return new ExpressionScope(kParameterDeclaration);\n}\n\nexport function newArrowHeadScope() {\n  return new ArrowHeadParsingScope(kMaybeArrowParameterDeclaration);\n}\n\nexport function newAsyncArrowScope() {\n  return new ArrowHeadParsingScope(kMaybeAsyncArrowParameterDeclaration);\n}\n\nexport function newExpressionScope() {\n  return new ExpressionScope();\n}\n"],"mappings":"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"}���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������lib/util/identifier.js������������������������������������������������������������������������������0000644�����������������00000004404�15120211212�0010734 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.canBeReservedWord = canBeReservedWord;
Object.defineProperty(exports, "isIdentifierChar", {
  enumerable: true,
  get: function () {
    return _helperValidatorIdentifier.isIdentifierChar;
  }
});
Object.defineProperty(exports, "isIdentifierStart", {
  enumerable: true,
  get: function () {
    return _helperValidatorIdentifier.isIdentifierStart;
  }
});
exports.isIteratorStart = isIteratorStart;
Object.defineProperty(exports, "isKeyword", {
  enumerable: true,
  get: function () {
    return _helperValidatorIdentifier.isKeyword;
  }
});
Object.defineProperty(exports, "isReservedWord", {
  enumerable: true,
  get: function () {
    return _helperValidatorIdentifier.isReservedWord;
  }
});
Object.defineProperty(exports, "isStrictBindOnlyReservedWord", {
  enumerable: true,
  get: function () {
    return _helperValidatorIdentifier.isStrictBindOnlyReservedWord;
  }
});
Object.defineProperty(exports, "isStrictBindReservedWord", {
  enumerable: true,
  get: function () {
    return _helperValidatorIdentifier.isStrictBindReservedWord;
  }
});
Object.defineProperty(exports, "isStrictReservedWord", {
  enumerable: true,
  get: function () {
    return _helperValidatorIdentifier.isStrictReservedWord;
  }
});
exports.keywordRelationalOperator = void 0;
var _helperValidatorIdentifier = require("@babel/helper-validator-identifier");
const keywordRelationalOperator = /^in(stanceof)?$/;
exports.keywordRelationalOperator = keywordRelationalOperator;
function isIteratorStart(current, next, next2) {
  return current === 64 && next === 64 && (0, _helperValidatorIdentifier.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);
}

//# sourceMappingURL=identifier.js.map
������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������lib/util/identifier.js.map��������������������������������������������������������������������������0000644�����������������00000006051�15120211213�0011511 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������{"version":3,"names":["_helperValidatorIdentifier","require","keywordRelationalOperator","exports","isIteratorStart","current","next","next2","isIdentifierStart","reservedWordLikeSet","Set","canBeReservedWord","word","has"],"sources":["../../src/util/identifier.ts"],"sourcesContent":["/* eslint max-len: 0 */\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"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA,IAAAA,0BAAA,GAAAC,OAAA;AAYO,MAAMC,yBAAyB,GAAG,iBAAiB;AAACC,OAAA,CAAAD,yBAAA,GAAAA,yBAAA;AAIpD,SAASE,eAAeA,CAC7BC,OAAe,EACfC,IAAY,EACZC,KAAa,EACJ;EACT,OACEF,OAAO,OAAqB,IAC5BC,IAAI,OAAqB,IACzB,IAAAE,4CAAiB,EAACD,KAAK,CAAC;AAE5B;AAOA,MAAME,mBAAmB,GAAG,IAAIC,GAAG,CAAC,CAClC,OAAO,EACP,MAAM,EACN,OAAO,EACP,UAAU,EACV,UAAU,EACV,SAAS,EACT,IAAI,EACJ,MAAM,EACN,SAAS,EACT,KAAK,EACL,UAAU,EACV,IAAI,EACJ,QAAQ,EACR,QAAQ,EACR,OAAO,EACP,KAAK,EACL,KAAK,EACL,OAAO,EACP,OAAO,EACP,MAAM,EACN,KAAK,EACL,MAAM,EACN,OAAO,EACP,OAAO,EACP,SAAS,EACT,QAAQ,EACR,QAAQ,EACR,MAAM,EACN,MAAM,EACN,OAAO,EACP,IAAI,EACJ,YAAY,EACZ,QAAQ,EACR,MAAM,EACN,QAAQ,EAER,YAAY,EACZ,WAAW,EACX,KAAK,EACL,SAAS,EACT,SAAS,EACT,WAAW,EACX,QAAQ,EACR,QAAQ,EACR,OAAO,EAEP,MAAM,EACN,WAAW,EAEX,MAAM,EACN,OAAO,CACR,CAAC;AAEK,SAASC,iBAAiBA,CAACC,IAAY,EAAW;EACvD,OAAOH,mBAAmB,CAACI,GAAG,CAACD,IAAI,CAAC;AACtC"}���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������lib/util/location.js��������������������������������������������������������������������������������0000644�����������������00000001635�15120211213�0010426 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.SourceLocation = exports.Position = void 0;
exports.createPositionWithColumnOffset = createPositionWithColumnOffset;
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;
  }
}
exports.Position = Position;
class SourceLocation {
  constructor(start, end) {
    this.start = void 0;
    this.end = void 0;
    this.filename = void 0;
    this.identifierName = void 0;
    this.start = start;
    this.end = end;
  }
}
exports.SourceLocation = SourceLocation;
function createPositionWithColumnOffset(position, columnOffset) {
  const {
    line,
    column,
    index
  } = position;
  return new Position(line, column + columnOffset, index + columnOffset);
}

//# sourceMappingURL=location.js.map
���������������������������������������������������������������������������������������������������lib/util/location.js.map����������������������������������������������������������������������������0000644�����������������00000004164�15120211213�0011202 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������{"version":3,"names":["Position","constructor","line","col","index","column","exports","SourceLocation","start","end","filename","identifierName","createPositionWithColumnOffset","position","columnOffset"],"sources":["../../src/util/location.ts"],"sourcesContent":["export 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 | undefined | null;\n\n  constructor(start: Position, end?: Position) {\n    this.start = start;\n    // (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 */\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"],"mappings":";;;;;;;AAOO,MAAMA,QAAQ,CAAC;EAKpBC,WAAWA,CAACC,IAAY,EAAEC,GAAW,EAAEC,KAAa,EAAE;IAAA,KAJtDF,IAAI;IAAA,KACJG,MAAM;IAAA,KACND,KAAK;IAGH,IAAI,CAACF,IAAI,GAAGA,IAAI;IAChB,IAAI,CAACG,MAAM,GAAGF,GAAG;IACjB,IAAI,CAACC,KAAK,GAAGA,KAAK;EACpB;AACF;AAACE,OAAA,CAAAN,QAAA,GAAAA,QAAA;AAEM,MAAMO,cAAc,CAAC;EAM1BN,WAAWA,CAACO,KAAe,EAAEC,GAAc,EAAE;IAAA,KAL7CD,KAAK;IAAA,KACLC,GAAG;IAAA,KACHC,QAAQ;IAAA,KACRC,cAAc;IAGZ,IAAI,CAACH,KAAK,GAAGA,KAAK;IAElB,IAAI,CAACC,GAAG,GAAGA,GAAG;EAChB;AACF;AAACH,OAAA,CAAAC,cAAA,GAAAA,cAAA;AAQM,SAASK,8BAA8BA,CAC5CC,QAAkB,EAClBC,YAAoB,EACpB;EACA,MAAM;IAAEZ,IAAI;IAAEG,MAAM;IAAED;EAAM,CAAC,GAAGS,QAAQ;EACxC,OAAO,IAAIb,QAAQ,CAACE,IAAI,EAAEG,MAAM,GAAGS,YAAY,EAAEV,KAAK,GAAGU,YAAY,CAAC;AACxE"}������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������lib/util/production-parameter.js��������������������������������������������������������������������0000644�����������������00000002373�15120211213�0012762 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������"use strict";

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

//# sourceMappingURL=production-parameter.js.map
���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������lib/util/production-parameter.js.map����������������������������������������������������������������0000644�����������������00000007444�15120211213�0013542 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������{"version":3,"names":["PARAM","PARAM_YIELD","PARAM_AWAIT","PARAM_RETURN","PARAM_IN","exports","ProductionParameterHandler","constructor","stacks","enter","flags","push","exit","pop","currentFlags","length","hasAwait","hasYield","hasReturn","hasIn","default","functionFlags","isAsync","isGenerator"],"sources":["../../src/util/production-parameter.ts"],"sourcesContent":["export const // Initial Parameter flags\n  PARAM = 0b0000,\n  // track [Yield] production parameter\n  PARAM_YIELD = 0b0001,\n  // track [Await] production parameter\n  PARAM_AWAIT = 0b0010,\n  // track [Return] production parameter\n  PARAM_RETURN = 0b0100,\n  PARAM_IN = 0b1000; // track [In] production parameter\n\n// ProductionParameterHandler is a stack fashioned production parameter tracker\n// https://tc39.es/ecma262/#sec-grammar-notation\n// The tracked parameters are defined above.\n//\n// Whenever [+Await]/[+Yield] appears in the right-hand sides of a production,\n// we must enter a new tracking stack. For example when parsing\n//\n// AsyncFunctionDeclaration [Yield, Await]:\n//   async [no LineTerminator here] function BindingIdentifier[?Yield, ?Await]\n//     ( FormalParameters[~Yield, +Await] ) { AsyncFunctionBody }\n//\n// we must follow such process:\n//\n// 1. parse async keyword\n// 2. parse function keyword\n// 3. parse bindingIdentifier <= inherit current parameters: [?Await]\n// 4. enter new stack with (PARAM_AWAIT)\n// 5. parse formal parameters <= must have [Await] parameter [+Await]\n// 6. parse function body\n// 7. exit current stack\n\nexport type ParamKind = number;\n\n// todo(flow->ts) - check if more granular type can be used,\n//  type below is not good because things like PARAM_AWAIT|PARAM_YIELD are not included\n// export type ParamKind =\n//   | typeof PARAM\n//   | typeof PARAM_AWAIT\n//   | typeof PARAM_IN\n//   | typeof PARAM_RETURN\n//   | typeof PARAM_YIELD;\n\nexport default class ProductionParameterHandler {\n  stacks: Array<number> = [];\n  enter(flags: number) {\n    this.stacks.push(flags);\n  }\n\n  exit() {\n    this.stacks.pop();\n  }\n\n  currentFlags(): number {\n    return this.stacks[this.stacks.length - 1];\n  }\n\n  get hasAwait(): boolean {\n    return (this.currentFlags() & PARAM_AWAIT) > 0;\n  }\n\n  get hasYield(): boolean {\n    return (this.currentFlags() & PARAM_YIELD) > 0;\n  }\n\n  get hasReturn(): boolean {\n    return (this.currentFlags() & PARAM_RETURN) > 0;\n  }\n\n  get hasIn(): boolean {\n    return (this.currentFlags() & PARAM_IN) > 0;\n  }\n}\n\nexport function functionFlags(\n  isAsync: boolean,\n  isGenerator: boolean,\n): ParamKind {\n  return (isAsync ? PARAM_AWAIT : 0) | (isGenerator ? PARAM_YIELD : 0);\n}\n"],"mappings":";;;;;;;AAAO,MACLA,KAAK,GAAG,MAAM;EAEdC,WAAW,GAAG,MAAM;EAEpBC,WAAW,GAAG,MAAM;EAEpBC,YAAY,GAAG,MAAM;EACrBC,QAAQ,GAAG,MAAM;AAACC,OAAA,CAAAD,QAAA,GAAAA,QAAA;AAAAC,OAAA,CAAAF,YAAA,GAAAA,YAAA;AAAAE,OAAA,CAAAH,WAAA,GAAAA,WAAA;AAAAG,OAAA,CAAAJ,WAAA,GAAAA,WAAA;AAAAI,OAAA,CAAAL,KAAA,GAAAA,KAAA;AAkCL,MAAMM,0BAA0B,CAAC;EAAAC,YAAA;IAAA,KAC9CC,MAAM,GAAkB,EAAE;EAAA;EAC1BC,KAAKA,CAACC,KAAa,EAAE;IACnB,IAAI,CAACF,MAAM,CAACG,IAAI,CAACD,KAAK,CAAC;EACzB;EAEAE,IAAIA,CAAA,EAAG;IACL,IAAI,CAACJ,MAAM,CAACK,GAAG,CAAC,CAAC;EACnB;EAEAC,YAAYA,CAAA,EAAW;IACrB,OAAO,IAAI,CAACN,MAAM,CAAC,IAAI,CAACA,MAAM,CAACO,MAAM,GAAG,CAAC,CAAC;EAC5C;EAEA,IAAIC,QAAQA,CAAA,EAAY;IACtB,OAAO,CAAC,IAAI,CAACF,YAAY,CAAC,CAAC,GAAGZ,WAAW,IAAI,CAAC;EAChD;EAEA,IAAIe,QAAQA,CAAA,EAAY;IACtB,OAAO,CAAC,IAAI,CAACH,YAAY,CAAC,CAAC,GAAGb,WAAW,IAAI,CAAC;EAChD;EAEA,IAAIiB,SAASA,CAAA,EAAY;IACvB,OAAO,CAAC,IAAI,CAACJ,YAAY,CAAC,CAAC,GAAGX,YAAY,IAAI,CAAC;EACjD;EAEA,IAAIgB,KAAKA,CAAA,EAAY;IACnB,OAAO,CAAC,IAAI,CAACL,YAAY,CAAC,CAAC,GAAGV,QAAQ,IAAI,CAAC;EAC7C;AACF;AAACC,OAAA,CAAAe,OAAA,GAAAd,0BAAA;AAEM,SAASe,aAAaA,CAC3BC,OAAgB,EAChBC,WAAoB,EACT;EACX,OAAO,CAACD,OAAO,GAAGpB,WAAW,GAAG,CAAC,KAAKqB,WAAW,GAAGtB,WAAW,GAAG,CAAC,CAAC;AACtE"}����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������lib/util/scope.js�����������������������������������������������������������������������������������0000644�����������������00000012232�15120211213�0007722 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = exports.Scope = void 0;
var _scopeflags = require("./scopeflags");
var _parseError = require("../parse-error");
class Scope {
  constructor(flags) {
    this.var = new Set();
    this.lexical = new Set();
    this.functions = new Set();
    this.flags = flags;
  }
}
exports.Scope = Scope;
class ScopeHandler {
  constructor(parser, inModule) {
    this.parser = void 0;
    this.scopeStack = [];
    this.inModule = void 0;
    this.undefinedExports = new Map();
    this.parser = parser;
    this.inModule = inModule;
  }
  get inTopLevel() {
    return (this.currentScope().flags & _scopeflags.SCOPE_PROGRAM) > 0;
  }
  get inFunction() {
    return (this.currentVarScopeFlags() & _scopeflags.SCOPE_FUNCTION) > 0;
  }
  get allowSuper() {
    return (this.currentThisScopeFlags() & _scopeflags.SCOPE_SUPER) > 0;
  }
  get allowDirectSuper() {
    return (this.currentThisScopeFlags() & _scopeflags.SCOPE_DIRECT_SUPER) > 0;
  }
  get inClass() {
    return (this.currentThisScopeFlags() & _scopeflags.SCOPE_CLASS) > 0;
  }
  get inClassAndNotInNonArrowFunction() {
    const flags = this.currentThisScopeFlags();
    return (flags & _scopeflags.SCOPE_CLASS) > 0 && (flags & _scopeflags.SCOPE_FUNCTION) === 0;
  }
  get inStaticBlock() {
    for (let i = this.scopeStack.length - 1;; i--) {
      const {
        flags
      } = this.scopeStack[i];
      if (flags & _scopeflags.SCOPE_STATIC_BLOCK) {
        return true;
      }
      if (flags & (_scopeflags.SCOPE_VAR | _scopeflags.SCOPE_CLASS)) {
        return false;
      }
    }
  }
  get inNonArrowFunction() {
    return (this.currentThisScopeFlags() & _scopeflags.SCOPE_FUNCTION) > 0;
  }
  get treatFunctionsAsVar() {
    return this.treatFunctionsAsVarInScope(this.currentScope());
  }
  createScope(flags) {
    return new Scope(flags);
  }
  enter(flags) {
    this.scopeStack.push(this.createScope(flags));
  }
  exit() {
    const scope = this.scopeStack.pop();
    return scope.flags;
  }
  treatFunctionsAsVarInScope(scope) {
    return !!(scope.flags & (_scopeflags.SCOPE_FUNCTION | _scopeflags.SCOPE_STATIC_BLOCK) || !this.parser.inModule && scope.flags & _scopeflags.SCOPE_PROGRAM);
  }
  declareName(name, bindingType, loc) {
    let scope = this.currentScope();
    if (bindingType & _scopeflags.BIND_SCOPE_LEXICAL || bindingType & _scopeflags.BIND_SCOPE_FUNCTION) {
      this.checkRedeclarationInScope(scope, name, bindingType, loc);
      if (bindingType & _scopeflags.BIND_SCOPE_FUNCTION) {
        scope.functions.add(name);
      } else {
        scope.lexical.add(name);
      }
      if (bindingType & _scopeflags.BIND_SCOPE_LEXICAL) {
        this.maybeExportDefined(scope, name);
      }
    } else if (bindingType & _scopeflags.BIND_SCOPE_VAR) {
      for (let i = this.scopeStack.length - 1; i >= 0; --i) {
        scope = this.scopeStack[i];
        this.checkRedeclarationInScope(scope, name, bindingType, loc);
        scope.var.add(name);
        this.maybeExportDefined(scope, name);
        if (scope.flags & _scopeflags.SCOPE_VAR) break;
      }
    }
    if (this.parser.inModule && scope.flags & _scopeflags.SCOPE_PROGRAM) {
      this.undefinedExports.delete(name);
    }
  }
  maybeExportDefined(scope, name) {
    if (this.parser.inModule && scope.flags & _scopeflags.SCOPE_PROGRAM) {
      this.undefinedExports.delete(name);
    }
  }
  checkRedeclarationInScope(scope, name, bindingType, loc) {
    if (this.isRedeclaredInScope(scope, name, bindingType)) {
      this.parser.raise(_parseError.Errors.VarRedeclaration, {
        at: loc,
        identifierName: name
      });
    }
  }
  isRedeclaredInScope(scope, name, bindingType) {
    if (!(bindingType & _scopeflags.BIND_KIND_VALUE)) return false;
    if (bindingType & _scopeflags.BIND_SCOPE_LEXICAL) {
      return scope.lexical.has(name) || scope.functions.has(name) || scope.var.has(name);
    }
    if (bindingType & _scopeflags.BIND_SCOPE_FUNCTION) {
      return scope.lexical.has(name) || !this.treatFunctionsAsVarInScope(scope) && scope.var.has(name);
    }
    return scope.lexical.has(name) && !(scope.flags & _scopeflags.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 & _scopeflags.SCOPE_VAR) {
        return flags;
      }
    }
  }
  currentThisScopeFlags() {
    for (let i = this.scopeStack.length - 1;; i--) {
      const {
        flags
      } = this.scopeStack[i];
      if (flags & (_scopeflags.SCOPE_VAR | _scopeflags.SCOPE_CLASS) && !(flags & _scopeflags.SCOPE_ARROW)) {
        return flags;
      }
    }
  }
}
exports.default = ScopeHandler;

//# sourceMappingURL=scope.js.map
����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������lib/util/scope.js.map�������������������������������������������������������������������������������0000644�����������������00000032764�15120211213�0010512 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������{"version":3,"names":["_scopeflags","require","_parseError","Scope","constructor","flags","var","Set","lexical","functions","exports","ScopeHandler","parser","inModule","scopeStack","undefinedExports","Map","inTopLevel","currentScope","SCOPE_PROGRAM","inFunction","currentVarScopeFlags","SCOPE_FUNCTION","allowSuper","currentThisScopeFlags","SCOPE_SUPER","allowDirectSuper","SCOPE_DIRECT_SUPER","inClass","SCOPE_CLASS","inClassAndNotInNonArrowFunction","inStaticBlock","i","length","SCOPE_STATIC_BLOCK","SCOPE_VAR","inNonArrowFunction","treatFunctionsAsVar","treatFunctionsAsVarInScope","createScope","enter","push","exit","scope","pop","declareName","name","bindingType","loc","BIND_SCOPE_LEXICAL","BIND_SCOPE_FUNCTION","checkRedeclarationInScope","add","maybeExportDefined","BIND_SCOPE_VAR","delete","isRedeclaredInScope","raise","Errors","VarRedeclaration","at","identifierName","BIND_KIND_VALUE","has","SCOPE_SIMPLE_CATCH","values","next","value","checkLocalExport","id","topLevelScope","set","start","SCOPE_ARROW","default"],"sources":["../../src/util/scope.ts"],"sourcesContent":["import {\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 type { Position } from \"./location\";\nimport type * as N from \"../types\";\nimport { Errors } from \"../parse-error\";\nimport type Tokenizer from \"../tokenizer\";\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<string> = new Set();\n  // A set of lexically-declared names in the current lexical scope\n  lexical: Set<string> = new Set();\n  // A set of lexically-declared FunctionDeclaration names in the current lexical scope\n  functions: Set<string> = 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<IScope extends Scope = Scope> {\n  parser: Tokenizer;\n  scopeStack: Array<IScope> = [];\n  inModule: boolean;\n  undefinedExports: Map<string, Position> = new Map();\n\n  constructor(parser: Tokenizer, inModule: boolean) {\n    this.parser = parser;\n    this.inModule = inModule;\n  }\n\n  get inTopLevel() {\n    return (this.currentScope().flags & SCOPE_PROGRAM) > 0;\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\n  enter(flags: ScopeFlags) {\n    /*:: +createScope: (flags: ScopeFlags) => IScope; */\n    // @ts-expect-error This method will be overwritten by subclasses\n    this.scopeStack.push(this.createScope(flags));\n  }\n\n  exit(): ScopeFlags {\n    const scope = this.scopeStack.pop();\n    return scope.flags;\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 | SCOPE_STATIC_BLOCK) ||\n      (!this.parser.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.parser.inModule && scope.flags & SCOPE_PROGRAM) {\n      this.undefinedExports.delete(name);\n    }\n  }\n\n  maybeExportDefined(scope: IScope, name: string) {\n    if (this.parser.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.parser.raise(Errors.VarRedeclaration, {\n        at: loc,\n        identifierName: name,\n      });\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        // Annex B.3.4\n        // https://tc39.es/ecma262/#sec-variablestatements-in-catch-blocks\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  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  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"],"mappings":"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"}������������lib/util/scopeflags.js������������������������������������������������������������������������������0000644�����������������00000014500�15120211213�0010737 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.SCOPE_VAR = exports.SCOPE_TS_MODULE = exports.SCOPE_SUPER = exports.SCOPE_STATIC_BLOCK = exports.SCOPE_SIMPLE_CATCH = exports.SCOPE_PROGRAM = exports.SCOPE_OTHER = exports.SCOPE_FUNCTION = exports.SCOPE_DIRECT_SUPER = exports.SCOPE_CLASS = exports.SCOPE_ARROW = exports.CLASS_ELEMENT_STATIC_SETTER = exports.CLASS_ELEMENT_STATIC_GETTER = exports.CLASS_ELEMENT_OTHER = exports.CLASS_ELEMENT_KIND_SETTER = exports.CLASS_ELEMENT_KIND_GETTER = exports.CLASS_ELEMENT_KIND_ACCESSOR = exports.CLASS_ELEMENT_INSTANCE_SETTER = exports.CLASS_ELEMENT_INSTANCE_GETTER = exports.CLASS_ELEMENT_FLAG_STATIC = exports.BIND_VAR = exports.BIND_TS_TYPE_IMPORT = exports.BIND_TS_TYPE = exports.BIND_TS_NAMESPACE = exports.BIND_TS_INTERFACE = exports.BIND_TS_ENUM = exports.BIND_TS_CONST_ENUM = exports.BIND_TS_AMBIENT = exports.BIND_SCOPE_VAR = exports.BIND_SCOPE_OUTSIDE = exports.BIND_SCOPE_LEXICAL = exports.BIND_SCOPE_FUNCTION = exports.BIND_OUTSIDE = exports.BIND_NONE = exports.BIND_LEXICAL = exports.BIND_KIND_VALUE = exports.BIND_KIND_TYPE = exports.BIND_FUNCTION = exports.BIND_FLOW_DECLARE_FN = exports.BIND_FLAGS_TS_IMPORT = exports.BIND_FLAGS_TS_EXPORT_ONLY = exports.BIND_FLAGS_TS_ENUM = exports.BIND_FLAGS_TS_CONST_ENUM = exports.BIND_FLAGS_NO_LET_IN_LEXICAL = exports.BIND_FLAGS_NONE = exports.BIND_FLAGS_FLOW_DECLARE_FN = exports.BIND_FLAGS_CLASS = exports.BIND_CLASS = exports.BIND_CATCH_PARAM = void 0;
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_STATIC_BLOCK | SCOPE_TS_MODULE;
exports.SCOPE_VAR = SCOPE_VAR;
exports.SCOPE_TS_MODULE = SCOPE_TS_MODULE;
exports.SCOPE_STATIC_BLOCK = SCOPE_STATIC_BLOCK;
exports.SCOPE_CLASS = SCOPE_CLASS;
exports.SCOPE_DIRECT_SUPER = SCOPE_DIRECT_SUPER;
exports.SCOPE_SUPER = SCOPE_SUPER;
exports.SCOPE_SIMPLE_CATCH = SCOPE_SIMPLE_CATCH;
exports.SCOPE_ARROW = SCOPE_ARROW;
exports.SCOPE_FUNCTION = SCOPE_FUNCTION;
exports.SCOPE_PROGRAM = SCOPE_PROGRAM;
exports.SCOPE_OTHER = SCOPE_OTHER;
const BIND_KIND_VALUE = 0b0000000000001,
  BIND_KIND_TYPE = 0b0000000000010,
  BIND_SCOPE_VAR = 0b0000000000100,
  BIND_SCOPE_LEXICAL = 0b0000000001000,
  BIND_SCOPE_FUNCTION = 0b0000000010000,
  BIND_SCOPE_OUTSIDE = 0b0000000100000,
  BIND_FLAGS_NONE = 0b00000001000000,
  BIND_FLAGS_CLASS = 0b00000010000000,
  BIND_FLAGS_TS_ENUM = 0b00000100000000,
  BIND_FLAGS_TS_CONST_ENUM = 0b00001000000000,
  BIND_FLAGS_TS_EXPORT_ONLY = 0b00010000000000,
  BIND_FLAGS_FLOW_DECLARE_FN = 0b00100000000000,
  BIND_FLAGS_TS_IMPORT = 0b01000000000000,
  BIND_FLAGS_NO_LET_IN_LEXICAL = 0b10000000000000;
exports.BIND_FLAGS_NO_LET_IN_LEXICAL = BIND_FLAGS_NO_LET_IN_LEXICAL;
exports.BIND_FLAGS_TS_IMPORT = BIND_FLAGS_TS_IMPORT;
exports.BIND_FLAGS_FLOW_DECLARE_FN = BIND_FLAGS_FLOW_DECLARE_FN;
exports.BIND_FLAGS_TS_EXPORT_ONLY = BIND_FLAGS_TS_EXPORT_ONLY;
exports.BIND_FLAGS_TS_CONST_ENUM = BIND_FLAGS_TS_CONST_ENUM;
exports.BIND_FLAGS_TS_ENUM = BIND_FLAGS_TS_ENUM;
exports.BIND_FLAGS_CLASS = BIND_FLAGS_CLASS;
exports.BIND_FLAGS_NONE = BIND_FLAGS_NONE;
exports.BIND_SCOPE_OUTSIDE = BIND_SCOPE_OUTSIDE;
exports.BIND_SCOPE_FUNCTION = BIND_SCOPE_FUNCTION;
exports.BIND_SCOPE_LEXICAL = BIND_SCOPE_LEXICAL;
exports.BIND_SCOPE_VAR = BIND_SCOPE_VAR;
exports.BIND_KIND_TYPE = BIND_KIND_TYPE;
exports.BIND_KIND_VALUE = BIND_KIND_VALUE;
const BIND_CLASS = BIND_KIND_VALUE | BIND_KIND_TYPE | BIND_SCOPE_LEXICAL | BIND_FLAGS_CLASS | BIND_FLAGS_NO_LET_IN_LEXICAL,
  BIND_LEXICAL = BIND_KIND_VALUE | 0 | BIND_SCOPE_LEXICAL | BIND_FLAGS_NO_LET_IN_LEXICAL,
  BIND_CATCH_PARAM = 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_FLAGS_NO_LET_IN_LEXICAL,
  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_TS_TYPE_IMPORT = 0 | BIND_KIND_TYPE | 0 | BIND_FLAGS_TS_IMPORT,
  BIND_FLOW_DECLARE_FN = BIND_FLAGS_FLOW_DECLARE_FN;
exports.BIND_FLOW_DECLARE_FN = BIND_FLOW_DECLARE_FN;
exports.BIND_TS_TYPE_IMPORT = BIND_TS_TYPE_IMPORT;
exports.BIND_TS_NAMESPACE = BIND_TS_NAMESPACE;
exports.BIND_TS_CONST_ENUM = BIND_TS_CONST_ENUM;
exports.BIND_OUTSIDE = BIND_OUTSIDE;
exports.BIND_NONE = BIND_NONE;
exports.BIND_TS_AMBIENT = BIND_TS_AMBIENT;
exports.BIND_TS_ENUM = BIND_TS_ENUM;
exports.BIND_TS_TYPE = BIND_TS_TYPE;
exports.BIND_TS_INTERFACE = BIND_TS_INTERFACE;
exports.BIND_FUNCTION = BIND_FUNCTION;
exports.BIND_VAR = BIND_VAR;
exports.BIND_CATCH_PARAM = BIND_CATCH_PARAM;
exports.BIND_LEXICAL = BIND_LEXICAL;
exports.BIND_CLASS = BIND_CLASS;
const CLASS_ELEMENT_FLAG_STATIC = 0b100,
  CLASS_ELEMENT_KIND_GETTER = 0b010,
  CLASS_ELEMENT_KIND_SETTER = 0b001,
  CLASS_ELEMENT_KIND_ACCESSOR = CLASS_ELEMENT_KIND_GETTER | CLASS_ELEMENT_KIND_SETTER;
exports.CLASS_ELEMENT_KIND_ACCESSOR = CLASS_ELEMENT_KIND_ACCESSOR;
exports.CLASS_ELEMENT_KIND_SETTER = CLASS_ELEMENT_KIND_SETTER;
exports.CLASS_ELEMENT_KIND_GETTER = CLASS_ELEMENT_KIND_GETTER;
exports.CLASS_ELEMENT_FLAG_STATIC = CLASS_ELEMENT_FLAG_STATIC;
const CLASS_ELEMENT_STATIC_GETTER = CLASS_ELEMENT_KIND_GETTER | CLASS_ELEMENT_FLAG_STATIC,
  CLASS_ELEMENT_STATIC_SETTER = CLASS_ELEMENT_KIND_SETTER | CLASS_ELEMENT_FLAG_STATIC,
  CLASS_ELEMENT_INSTANCE_GETTER = CLASS_ELEMENT_KIND_GETTER,
  CLASS_ELEMENT_INSTANCE_SETTER = CLASS_ELEMENT_KIND_SETTER,
  CLASS_ELEMENT_OTHER = 0;
exports.CLASS_ELEMENT_OTHER = CLASS_ELEMENT_OTHER;
exports.CLASS_ELEMENT_INSTANCE_SETTER = CLASS_ELEMENT_INSTANCE_SETTER;
exports.CLASS_ELEMENT_INSTANCE_GETTER = CLASS_ELEMENT_INSTANCE_GETTER;
exports.CLASS_ELEMENT_STATIC_SETTER = CLASS_ELEMENT_STATIC_SETTER;
exports.CLASS_ELEMENT_STATIC_GETTER = CLASS_ELEMENT_STATIC_GETTER;

//# sourceMappingURL=scopeflags.js.map
������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������lib/util/scopeflags.js.map��������������������������������������������������������������������������0000644�����������������00000024045�15120211213�0011520 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������{"version":3,"names":["SCOPE_OTHER","SCOPE_PROGRAM","SCOPE_FUNCTION","SCOPE_ARROW","SCOPE_SIMPLE_CATCH","SCOPE_SUPER","SCOPE_DIRECT_SUPER","SCOPE_CLASS","SCOPE_STATIC_BLOCK","SCOPE_TS_MODULE","SCOPE_VAR","exports","BIND_KIND_VALUE","BIND_KIND_TYPE","BIND_SCOPE_VAR","BIND_SCOPE_LEXICAL","BIND_SCOPE_FUNCTION","BIND_SCOPE_OUTSIDE","BIND_FLAGS_NONE","BIND_FLAGS_CLASS","BIND_FLAGS_TS_ENUM","BIND_FLAGS_TS_CONST_ENUM","BIND_FLAGS_TS_EXPORT_ONLY","BIND_FLAGS_FLOW_DECLARE_FN","BIND_FLAGS_TS_IMPORT","BIND_FLAGS_NO_LET_IN_LEXICAL","BIND_CLASS","BIND_LEXICAL","BIND_CATCH_PARAM","BIND_VAR","BIND_FUNCTION","BIND_TS_INTERFACE","BIND_TS_TYPE","BIND_TS_ENUM","BIND_TS_AMBIENT","BIND_NONE","BIND_OUTSIDE","BIND_TS_CONST_ENUM","BIND_TS_NAMESPACE","BIND_TS_TYPE_IMPORT","BIND_FLOW_DECLARE_FN","CLASS_ELEMENT_FLAG_STATIC","CLASS_ELEMENT_KIND_GETTER","CLASS_ELEMENT_KIND_SETTER","CLASS_ELEMENT_KIND_ACCESSOR","CLASS_ELEMENT_STATIC_GETTER","CLASS_ELEMENT_STATIC_SETTER","CLASS_ELEMENT_INSTANCE_GETTER","CLASS_ELEMENT_INSTANCE_SETTER","CLASS_ELEMENT_OTHER"],"sources":["../../src/util/scopeflags.ts"],"sourcesContent":["// 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_STATIC_BLOCK | 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            = 0b0000000_0000_01,\n             BIND_KIND_TYPE             = 0b0000000_0000_10,\n             // Used in checkLVal and declareName to determine the type of a binding\n             BIND_SCOPE_VAR             = 0b0000000_0001_00, // Var-style binding\n             BIND_SCOPE_LEXICAL         = 0b0000000_0010_00, // Let- or const-style binding\n             BIND_SCOPE_FUNCTION        = 0b0000000_0100_00, // Function declaration\n             BIND_SCOPE_OUTSIDE         = 0b0000000_1000_00, // Special case for function names as\n                                                   // bound inside the function\n             // Misc flags\n             BIND_FLAGS_NONE            = 0b00000001_0000_00,\n             BIND_FLAGS_CLASS           = 0b00000010_0000_00,\n             BIND_FLAGS_TS_ENUM         = 0b00000100_0000_00,\n             BIND_FLAGS_TS_CONST_ENUM   = 0b00001000_0000_00,\n             BIND_FLAGS_TS_EXPORT_ONLY  = 0b00010000_0000_00,\n             BIND_FLAGS_FLOW_DECLARE_FN = 0b00100000_0000_00,\n             BIND_FLAGS_TS_IMPORT       = 0b01000000_0000_00,\n             // Whether \"let\" should be allowed in bound names in sloppy mode\n             BIND_FLAGS_NO_LET_IN_LEXICAL = 0b10000000_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|BIND_FLAGS_NO_LET_IN_LEXICAL,\n             BIND_LEXICAL       = BIND_KIND_VALUE | 0              | BIND_SCOPE_LEXICAL  | BIND_FLAGS_NO_LET_IN_LEXICAL,\n             BIND_CATCH_PARAM   = 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|BIND_FLAGS_NO_LET_IN_LEXICAL,\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             BIND_TS_TYPE_IMPORT= 0               | BIND_KIND_TYPE | 0                   | BIND_FLAGS_TS_IMPORT     ,\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"],"mappings":"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"}�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������lib/util/whitespace.js������������������������������������������������������������������������������0000644�����������������00000003013�15120211213�0010742 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.isNewLine = isNewLine;
exports.isWhitespace = isWhitespace;
exports.skipWhiteSpaceToLineBreak = exports.skipWhiteSpaceInLine = exports.skipWhiteSpace = exports.lineBreakG = exports.lineBreak = void 0;
const lineBreak = /\r\n?|[\n\u2028\u2029]/;
exports.lineBreak = lineBreak;
const lineBreakG = new RegExp(lineBreak.source, "g");
exports.lineBreakG = lineBreakG;
function isNewLine(code) {
  switch (code) {
    case 10:
    case 13:
    case 8232:
    case 8233:
      return true;
    default:
      return false;
  }
}
const skipWhiteSpace = /(?:\s|\/\/.*|\/\*[^]*?\*\/)*/g;
exports.skipWhiteSpace = skipWhiteSpace;
const skipWhiteSpaceInLine = /(?:[^\S\n\r\u2028\u2029]|\/\/.*|\/\*.*?\*\/)*/g;
exports.skipWhiteSpaceInLine = skipWhiteSpaceInLine;
const skipWhiteSpaceToLineBreak = new RegExp("(?=(" + skipWhiteSpaceInLine.source + "))\\1" + /(?=[\n\r\u2028\u2029]|\/\*(?!.*?\*\/)|$)/.source, "y");
exports.skipWhiteSpaceToLineBreak = skipWhiteSpaceToLineBreak;
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;
  }
}

//# sourceMappingURL=whitespace.js.map
���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������lib/util/whitespace.js.map��������������������������������������������������������������������������0000644�����������������00000007421�15120211213�0011525 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������{"version":3,"names":["lineBreak","exports","lineBreakG","RegExp","source","isNewLine","code","skipWhiteSpace","skipWhiteSpaceInLine","skipWhiteSpaceToLineBreak","isWhitespace"],"sources":["../../src/util/whitespace.ts"],"sourcesContent":["import * 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]|\\/\\/.*|\\/\\*.*?\\*\\/)*/g;\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"],"mappings":";;;;;;;;AAIO,MAAMA,SAAS,GAAG,wBAAwB;AAACC,OAAA,CAAAD,SAAA,GAAAA,SAAA;AAC3C,MAAME,UAAU,GAAG,IAAIC,MAAM,CAACH,SAAS,CAACI,MAAM,EAAE,GAAG,CAAC;AAACH,OAAA,CAAAC,UAAA,GAAAA,UAAA;AAGrD,SAASG,SAASA,CAACC,IAAY,EAAW;EAC/C,QAAQA,IAAI;IACV;IACA;IACA;IACA;MACE,OAAO,IAAI;IAEb;MACE,OAAO,KAAK;EAChB;AACF;AAEO,MAAMC,cAAc,GAAG,+BAA+B;AAACN,OAAA,CAAAM,cAAA,GAAAA,cAAA;AAEvD,MAAMC,oBAAoB,GAC/B,gDAAgD;AAACP,OAAA,CAAAO,oBAAA,GAAAA,oBAAA;AAM5C,MAAMC,yBAAyB,GAAG,IAAIN,MAAM,CAIjD,MAAM,GAGJK,oBAAoB,CAACJ,MAAM,GAC3B,OAAO,GAGP,0CAA0C,CAACA,MAAM,EACnD,GACF,CAAC;AAACH,OAAA,CAAAQ,yBAAA,GAAAA,yBAAA;AAGK,SAASC,YAAYA,CAACJ,IAAY,EAAW;EAClD,QAAQA,IAAI;IACV,KAAK,MAAM;IACX,KAAK,MAAM;IACX,KAAK,MAAM;IACX;IACA;IACA;IACA,KAAK,MAAM;IACX,KAAK,MAAM;IACX,KAAK,MAAM;IACX,KAAK,MAAM;IACX,KAAK,MAAM;IACX,KAAK,MAAM;IACX,KAAK,MAAM;IACX,KAAK,MAAM;IACX,KAAK,MAAM;IACX,KAAK,MAAM;IACX,KAAK,MAAM;IACX,KAAK,MAAM;IACX,KAAK,MAAM;IACX,KAAK,MAAM;IACX,KAAK,MAAM;MACT,OAAO,IAAI;IAEb;MACE,OAAO,KAAK;EAChB;AACF"}�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������package.json����������������������������������������������������������������������������������������0000644�����������������00000002255�15120211213�0007022 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������{
  "name": "@babel/parser",
  "version": "7.22.5",
  "description": "A JavaScript parser",
  "author": "The Babel Team (https://babel.dev/team)",
  "homepage": "https://babel.dev/docs/en/next/babel-parser",
  "bugs": "https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A+parser+%28babylon%29%22+is%3Aopen",
  "license": "MIT",
  "publishConfig": {
    "access": "public"
  },
  "keywords": [
    "babel",
    "javascript",
    "parser",
    "tc39",
    "ecmascript",
    "@babel/parser"
  ],
  "repository": {
    "type": "git",
    "url": "https://github.com/babel/babel.git",
    "directory": "packages/babel-parser"
  },
  "main": "./lib/index.js",
  "types": "./typings/babel-parser.d.ts",
  "files": [
    "bin",
    "lib",
    "typings/babel-parser.d.ts",
    "index.cjs"
  ],
  "engines": {
    "node": ">=6.0.0"
  },
  "devDependencies": {
    "@babel/code-frame": "^7.22.5",
    "@babel/helper-check-duplicate-nodes": "^7.22.5",
    "@babel/helper-fixtures": "^7.22.5",
    "@babel/helper-string-parser": "^7.22.5",
    "@babel/helper-validator-identifier": "^7.22.5",
    "charcodes": "^0.2.0"
  },
  "bin": "./bin/babel-parser.js",
  "type": "commonjs"
}���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������typings/babel-parser.d.ts���������������������������������������������������������������������������0000644�����������������00000016011�15120211213�0011355 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������// This file is auto-generated! Do not modify it directly.
/* eslint-disable import/no-extraneous-dependencies, @typescript-eslint/consistent-type-imports, prettier/prettier */
import * as _babel_types from '@babel/types';

type Plugin =
  | "asyncDoExpressions"
  | "asyncGenerators"
  | "bigInt"
  | "classPrivateMethods"
  | "classPrivateProperties"
  | "classProperties"
  | "classStaticBlock" // Enabled by default
  | "decimal"
  | "decorators-legacy"
  | "decoratorAutoAccessors"
  | "destructuringPrivate"
  | "doExpressions"
  | "dynamicImport"
  | "explicitResourceManagement"
  | "exportDefaultFrom"
  | "exportNamespaceFrom" // deprecated
  | "flow"
  | "flowComments"
  | "functionBind"
  | "functionSent"
  | "importMeta"
  | "jsx"
  | "logicalAssignment"
  | "importAssertions" // deprecated
  | "importAttributes"
  | "importReflection"
  | "moduleBlocks"
  | "moduleStringNames"
  | "nullishCoalescingOperator"
  | "numericSeparator"
  | "objectRestSpread"
  | "optionalCatchBinding"
  | "optionalChaining"
  | "partialApplication"
  | "placeholders"
  | "privateIn" // Enabled by default
  | "regexpUnicodeSets" // Enabled by default
  | "throwExpressions"
  | "topLevelAwait"
  | "v8intrinsic"
  | ParserPluginWithOptions[0];

type ParserPluginWithOptions =
  | ["decorators", DecoratorsPluginOptions]
  | ["estree", { classFeatures?: boolean }]
  | ["importAttributes", { deprecatedAssertSyntax: boolean }]
  // @deprecated
  | ["moduleAttributes", { version: "may-2020" }]
  | ["pipelineOperator", PipelineOperatorPluginOptions]
  | ["recordAndTuple", RecordAndTuplePluginOptions]
  | ["flow", FlowPluginOptions]
  | ["typescript", TypeScriptPluginOptions];

type PluginConfig = Plugin | ParserPluginWithOptions;

interface DecoratorsPluginOptions {
  decoratorsBeforeExport?: boolean;
  allowCallParenthesized?: boolean;
}

interface PipelineOperatorPluginOptions {
  proposal: "minimal" | "fsharp" | "hack" | "smart";
  topicToken?: "%" | "#" | "@@" | "^^" | "^";
}

interface RecordAndTuplePluginOptions {
  syntaxType: "bar" | "hash";
}

interface FlowPluginOptions {
  all?: boolean;
  enums?: boolean;
}

interface TypeScriptPluginOptions {
  dts?: boolean;
  disallowAmbiguousJSXLike?: boolean;
}

// Type definitions for @babel/parser
// Project: https://github.com/babel/babel/tree/main/packages/babel-parser
// Definitions by: Troy Gerwien <https://github.com/yortus>
//                 Marvin Hagemeister <https://github.com/marvinhagemeister>
//                 Avi Vahl <https://github.com/AviVahl>
// TypeScript Version: 2.9

/**
 * Parse the provided code as an entire ECMAScript program.
 */
declare function parse(
  input: string,
  options?: ParserOptions
): ParseResult<_babel_types.File>;

/**
 * Parse the provided code as a single expression.
 */
declare function parseExpression(
  input: string,
  options?: ParserOptions
): ParseResult<_babel_types.Expression>;

interface ParserOptions {
  /**
   * By default, import and export declarations can only appear at a program's top level.
   * Setting this option to true allows them anywhere where a statement is allowed.
   */
  allowImportExportEverywhere?: boolean;

  /**
   * By default, await use is not allowed outside of an async function.
   * Set this to true to accept such code.
   */
  allowAwaitOutsideFunction?: boolean;

  /**
   * By default, a return statement at the top level raises an error.
   * Set this to true to accept such code.
   */
  allowReturnOutsideFunction?: boolean;

  /**
   * By default, new.target use is not allowed outside of a function or class.
   * Set this to true to accept such code.
   */
  allowNewTargetOutsideFunction?: boolean;

  allowSuperOutsideMethod?: boolean;

  /**
   * By default, exported identifiers must refer to a declared variable.
   * Set this to true to allow export statements to reference undeclared variables.
   */
  allowUndeclaredExports?: boolean;

  /**
   * By default, Babel parser JavaScript code according to Annex B syntax.
   * Set this to `false` to disable such behavior.
   */
  annexB?: boolean;

  /**
   * By default, Babel attaches comments to adjacent AST nodes.
   * When this option is set to false, comments are not attached.
   * It can provide up to 30% performance improvement when the input code has many comments.
   * @babel/eslint-parser will set it for you.
   * It is not recommended to use attachComment: false with Babel transform,
   * as doing so removes all the comments in output code, and renders annotations such as
   * /* istanbul ignore next *\/ nonfunctional.
   */
  attachComment?: boolean;

  /**
   * By default, Babel always throws an error when it finds some invalid code.
   * When this option is set to true, it will store the parsing error and
   * try to continue parsing the invalid input file.
   */
  errorRecovery?: boolean;

  /**
   * Indicate the mode the code should be parsed in.
   * Can be one of "script", "module", or "unambiguous". Defaults to "script".
   * "unambiguous" will make @babel/parser attempt to guess, based on the presence
   * of ES6 import or export statements.
   * Files with ES6 imports and exports are considered "module" and are otherwise "script".
   */
  sourceType?: "script" | "module" | "unambiguous";

  /**
   * Correlate output AST nodes with their source filename.
   * Useful when generating code and source maps from the ASTs of multiple input files.
   */
  sourceFilename?: string;

  /**
   * By default, the first line of code parsed is treated as line 1.
   * You can provide a line number to alternatively start with.
   * Useful for integration with other source tools.
   */
  startLine?: number;

  /**
   * By default, the parsed code is treated as if it starts from line 1, column 0.
   * You can provide a column number to alternatively start with.
   * Useful for integration with other source tools.
   */
  startColumn?: number;

  /**
   * Array containing the plugins that you want to enable.
   */
  plugins?: ParserPlugin[];

  /**
   * Should the parser work in strict mode.
   * Defaults to true if sourceType === 'module'. Otherwise, false.
   */
  strictMode?: boolean;

  /**
   * Adds a ranges property to each node: [node.start, node.end]
   */
  ranges?: boolean;

  /**
   * Adds all parsed tokens to a tokens property on the File node.
   */
  tokens?: boolean;

  /**
   * By default, the parser adds information about parentheses by setting
   * `extra.parenthesized` to `true` as needed.
   * When this option is `true` the parser creates `ParenthesizedExpression`
   * AST nodes instead of using the `extra` property.
   */
  createParenthesizedExpressions?: boolean;
}

type ParserPlugin = PluginConfig;


declare const tokTypes: {
  // todo(flow->ts) real token type
  [name: string]: any;
};

interface ParseError {
  code: string;
  reasonCode: string;
}

type ParseResult<Result> = Result & {
  errors: ParseError[];
};

export { DecoratorsPluginOptions, FlowPluginOptions, ParseError, ParseResult, ParserOptions, ParserPlugin, ParserPluginWithOptions, PipelineOperatorPluginOptions, RecordAndTuplePluginOptions, TypeScriptPluginOptions, parse, parseExpression, tokTypes };
���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������
User / IP	: 216.73.216.143
Host / Server	: 146.88.233.70 / dev.loger.cm
System	: Linux hybrid1120.fr.ns.planethoster.net 3.10.0-957.21.2.el7.x86_64 #1 SMP Wed Jun 5 14:26:44 UTC 2019 x86_64