@engine262/engine262 0.0.1-01e9fa95a4e8a1c042efd00492309a2de4998fd0

package/declaration/parser/ParseNode.d.mts

@@ -0,0 +1,1323 @@
+import type { ArrowInfo } from './Scope.mts';
+import type { Character, UnicodeCharacter } from '#self';
+export interface Position {
+    /** 1-based */
+    readonly line: number;
+    readonly column: number;
+}
+export interface Location {
+    readonly startIndex: number;
+    readonly endIndex: number;
+    readonly start: Position;
+    readonly end: Position;
+}
+export declare namespace ParseNode {
+    export interface BaseParseNode {
+        readonly type: ParseNode['type'];
+        readonly location: Location;
+        readonly strict: boolean;
+        readonly sourceText: string;
+        readonly parent: ParseNode | undefined;
+    }
+    export interface PrivateIdentifier extends BaseParseNode {
+        readonly type: 'PrivateIdentifier';
+        readonly name: string;
+    }
+    export interface IdentifierName extends BaseParseNode {
+        readonly type: 'IdentifierName';
+        readonly name: string;
+    }
+    export interface NullLiteral extends BaseParseNode {
+        readonly type: 'NullLiteral';
+    }
+    export interface BooleanLiteral extends BaseParseNode {
+        readonly type: 'BooleanLiteral';
+        readonly value: boolean;
+    }
+    export interface NumericLiteral extends BaseParseNode {
+        readonly type: 'NumericLiteral';
+        readonly value: number | bigint;
+    }
+    export interface StringLiteral extends BaseParseNode {
+        readonly type: 'StringLiteral';
+        readonly value: string;
+    }
+    export interface RegularExpressionLiteral extends BaseParseNode {
+        readonly type: 'RegularExpressionLiteral';
+        readonly RegularExpressionBody: string;
+        readonly RegularExpressionFlags: string;
+    }
+    export interface IdentifierReference extends BaseParseNode {
+        readonly type: 'IdentifierReference';
+        readonly escaped: boolean;
+        readonly name: string;
+    }
+    export interface BindingIdentifier extends BaseParseNode {
+        readonly type: 'BindingIdentifier';
+        readonly name: string;
+    }
+    export interface LabelIdentifier extends BaseParseNode {
+        readonly type: 'LabelIdentifier';
+        readonly name: string;
+    }
+    export type PrimaryExpression = ThisExpression | IdentifierReference | Literal | ArrayLiteral | ObjectLiteral | FunctionExpression | ClassExpression | GeneratorExpression | AsyncFunctionExpression | AsyncGeneratorExpression | RegularExpressionLiteral | TemplateLiteral | CoverParenthesizedExpressionAndArrowParameterList | ParenthesizedExpression;
+    export interface ThisExpression extends BaseParseNode {
+        readonly type: 'ThisExpression';
+    }
+    export interface CoverParenthesizedExpressionAndArrowParameterList extends BaseParseNode {
+        readonly type: 'CoverParenthesizedExpressionAndArrowParameterList';
+        readonly Arguments: readonly (ArgumentListElement | BindingRestElement)[];
+        readonly arrowInfo?: ArrowInfo;
+    }
+    export interface ParenthesizedExpression extends BaseParseNode {
+        readonly type: 'ParenthesizedExpression';
+        readonly Expression: Expression;
+    }
+    export type Literal = NullLiteral | BooleanLiteral | NumericLiteral | StringLiteral;
+    export interface ArrayLiteral extends BaseParseNode {
+        readonly type: 'ArrayLiteral';
+        readonly ElementList: ElementList;
+        readonly hasTrailingComma: boolean;
+    }
+    export type ElementList = readonly ElementListElement[];
+    export type ElementListElement = AssignmentExpressionOrHigher | SpreadElement | Elision;
+    export interface Elision extends BaseParseNode {
+        readonly type: 'Elision';
+    }
+    export interface SpreadElement extends BaseParseNode {
+        readonly type: 'SpreadElement';
+        readonly AssignmentExpression: AssignmentExpressionOrHigher;
+    }
+    export interface ObjectLiteral extends BaseParseNode {
+        readonly type: 'ObjectLiteral';
+        readonly PropertyDefinitionList: PropertyDefinitionList;
+        readonly hasTrailingComma: boolean;
+    }
+    export type PropertyDefinitionList = readonly PropertyDefinitionLike[];
+    export type PropertyDefinitionLike = IdentifierReference | CoverInitializedName | PropertyDefinition | MethodDefinitionLike;
+    export interface PropertyDefinition extends BaseParseNode {
+        readonly type: 'PropertyDefinition';
+        readonly PropertyName: PropertyNameLike | null;
+        readonly AssignmentExpression: AssignmentExpressionOrHigher;
+    }
+    export type PropertyNameLike = PropertyName | StringLiteral | NumericLiteral | IdentifierName;
+    export interface PropertyName extends BaseParseNode {
+        readonly type: 'PropertyName';
+        readonly ComputedPropertyName: AssignmentExpressionOrHigher;
+    }
+    export interface CoverInitializedName extends BaseParseNode {
+        readonly type: 'CoverInitializedName';
+        readonly IdentifierReference: IdentifierReference;
+        readonly Initializer: Initializer | null;
+    }
+    export type Initializer = AssignmentExpressionOrHigher;
+    export interface TemplateLiteral extends BaseParseNode {
+        readonly type: 'TemplateLiteral';
+        readonly TemplateSpanList: readonly string[];
+        readonly ExpressionList: readonly Expression[];
+    }
+    export type MemberExpressionOrHigher = PrimaryExpression | MemberExpression | SuperProperty | MetaProperty | NewExpression;
+    export interface MemberExpression extends BaseParseNode {
+        readonly type: 'MemberExpression';
+        readonly MemberExpression: LeftHandSideExpression;
+        readonly Expression: Expression | null;
+        readonly IdentifierName: IdentifierName | null;
+        readonly PrivateIdentifier: PrivateIdentifier | null;
+    }
+    export interface SuperProperty extends BaseParseNode {
+        readonly type: 'SuperProperty';
+        readonly Expression: Expression | null;
+        readonly IdentifierName: IdentifierName | null;
+    }
+    export type MetaProperty = NewTarget | ImportMeta;
+    export interface NewTarget extends BaseParseNode {
+        readonly type: 'NewTarget';
+    }
+    export interface ImportMeta extends BaseParseNode {
+        readonly type: 'ImportMeta';
+    }
+    export type NewExpressionOrHigher = MemberExpressionOrHigher | NewExpression;
+    export interface NewExpression extends BaseParseNode {
+        readonly type: 'NewExpression';
+        readonly MemberExpression: LeftHandSideExpression;
+        readonly Arguments: Arguments | null;
+    }
+    export type CallExpressionOrHigher = SuperCall | ImportCall | CallExpression | MemberExpression | TaggedTemplateExpression;
+    export interface CallExpression extends BaseParseNode {
+        readonly type: 'CallExpression';
+        readonly CallExpression: CallExpressionOrHigher | MemberExpressionOrHigher;
+        readonly Arguments: Arguments;
+        readonly arrowInfo?: ArrowInfo;
+    }
+    export interface TaggedTemplateExpression extends BaseParseNode {
+        readonly type: 'TaggedTemplateExpression';
+        readonly MemberExpression: CallExpressionOrHigher | MemberExpressionOrHigher;
+        readonly TemplateLiteral: TemplateLiteral;
+        readonly arrowInfo?: ArrowInfo;
+    }
+    export interface SuperCall extends BaseParseNode {
+        readonly type: 'SuperCall';
+        readonly Arguments: Arguments;
+    }
+    export interface ImportCall extends BaseParseNode {
+        readonly type: 'ImportCall';
+        readonly Phase: 'source' | 'defer' | 'evaluation';
+        readonly AssignmentExpression: AssignmentExpressionOrHigher;
+        readonly OptionsExpression?: AssignmentExpressionOrHigher;
+    }
+    export type Arguments = readonly ArgumentListElement[] & {
+        readonly location: Location;
+    };
+    export type ArgumentListElement = AssignmentExpressionOrHigher | AssignmentRestElement;
+    export interface OptionalExpression extends BaseParseNode {
+        readonly type: 'OptionalExpression';
+        readonly MemberExpression: MemberExpressionOrHigher | CallExpressionOrHigher | OptionalExpression;
+        readonly OptionalChain: OptionalChain;
+    }
+    export interface OptionalChain extends BaseParseNode {
+        readonly type: 'OptionalChain';
+        readonly OptionalChain: OptionalChain | null;
+        readonly Arguments?: Arguments;
+        readonly Expression?: Expression;
+        readonly IdentifierName?: IdentifierName;
+        readonly PrivateIdentifier?: PrivateIdentifier;
+    }
+    export type LeftHandSideExpression = NewExpressionOrHigher | CallExpressionOrHigher | OptionalExpression;
+    export type UpdateExpressionOrHigher = LeftHandSideExpression | UpdateExpression;
+    export interface UpdateExpression extends BaseParseNode {
+        readonly type: 'UpdateExpression';
+        readonly operator: '++' | '--';
+        readonly LeftHandSideExpression: LeftHandSideExpression | null;
+        readonly UnaryExpression: UnaryExpressionOrHigher | null;
+    }
+    export type UnaryExpressionOrHigher = UpdateExpressionOrHigher | UnaryExpression | AwaitExpression;
+    export interface UnaryExpression extends BaseParseNode {
+        readonly type: 'UnaryExpression';
+        readonly operator: 'delete' | 'void' | 'typeof' | '+' | '-' | '~' | '!';
+        readonly UnaryExpression: UnaryExpressionOrHigher;
+    }
+    export type ExponentiationExpressionOrHigher = UnaryExpressionOrHigher | ExponentiationExpression;
+    export interface ExponentiationExpression extends BaseParseNode {
+        readonly type: 'ExponentiationExpression';
+        readonly UpdateExpression: UpdateExpressionOrHigher;
+        readonly ExponentiationExpression: ExponentiationExpressionOrHigher;
+    }
+    export type MultiplicativeExpressionOrHigher = ExponentiationExpressionOrHigher | MultiplicativeExpression;
+    export interface MultiplicativeExpression extends BaseParseNode {
+        readonly type: 'MultiplicativeExpression';
+        readonly MultiplicativeExpression: MultiplicativeExpressionOrHigher;
+        readonly MultiplicativeOperator: MultiplicativeOperator;
+        readonly ExponentiationExpression: ExponentiationExpressionOrHigher;
+    }
+    export type MultiplicativeOperator = '*' | '/' | '%';
+    export type AdditiveExpressionOrHigher = MultiplicativeExpressionOrHigher | AdditiveExpression;
+    export interface AdditiveExpression extends BaseParseNode {
+        readonly type: 'AdditiveExpression';
+        readonly operator: '+' | '-';
+        readonly AdditiveExpression: AdditiveExpressionOrHigher;
+        readonly MultiplicativeExpression: MultiplicativeExpressionOrHigher;
+    }
+    export type ShiftExpressionOrHigher = AdditiveExpressionOrHigher | ShiftExpression;
+    export interface ShiftExpression extends BaseParseNode {
+        readonly type: 'ShiftExpression';
+        readonly operator: '<<' | '>>' | '>>>';
+        readonly ShiftExpression: ShiftExpressionOrHigher;
+        readonly AdditiveExpression: AdditiveExpressionOrHigher;
+    }
+    export type RelationalExpressionOrHigher = ShiftExpressionOrHigher | RelationalExpression;
+    export interface RelationalExpression extends BaseParseNode {
+        readonly type: 'RelationalExpression';
+        readonly operator: '<' | '>' | '<=' | '>=' | 'instanceof' | 'in';
+        readonly PrivateIdentifier?: PrivateIdentifier;
+        readonly RelationalExpression?: RelationalExpressionOrHigher;
+        readonly ShiftExpression: ShiftExpressionOrHigher;
+    }
+    export type EqualityExpressionOrHigher = RelationalExpressionOrHigher | EqualityExpression;
+    export interface EqualityExpression extends BaseParseNode {
+        readonly type: 'EqualityExpression';
+        readonly operator: '==' | '!=' | '===' | '!==';
+        readonly EqualityExpression: EqualityExpressionOrHigher;
+        readonly RelationalExpression: RelationalExpressionOrHigher;
+    }
+    export type BitwiseANDExpressionOrHigher = EqualityExpressionOrHigher | BitwiseANDExpression;
+    export interface BitwiseANDExpression extends BaseParseNode {
+        readonly type: 'BitwiseANDExpression';
+        readonly operator: '&';
+        readonly A: BitwiseANDExpressionOrHigher;
+        readonly B: EqualityExpressionOrHigher;
+    }
+    export type BitwiseXORExpressionOrHigher = BitwiseANDExpressionOrHigher | BitwiseXORExpression;
+    export interface BitwiseXORExpression extends BaseParseNode {
+        readonly type: 'BitwiseXORExpression';
+        readonly operator: '^';
+        readonly A: BitwiseXORExpressionOrHigher;
+        readonly B: BitwiseANDExpressionOrHigher;
+    }
+    export type BitwiseORExpressionOrHigher = BitwiseXORExpressionOrHigher | BitwiseORExpression;
+    export interface BitwiseORExpression extends BaseParseNode {
+        readonly type: 'BitwiseORExpression';
+        readonly operator: '|';
+        readonly A: BitwiseORExpressionOrHigher;
+        readonly B: BitwiseXORExpressionOrHigher;
+    }
+    export type LogicalANDExpressionOrHigher = BitwiseORExpressionOrHigher | LogicalANDExpression;
+    export interface LogicalANDExpression extends BaseParseNode {
+        readonly type: 'LogicalANDExpression';
+        readonly LogicalANDExpression: LogicalANDExpressionOrHigher;
+        readonly BitwiseORExpression: BitwiseORExpressionOrHigher;
+    }
+    export type LogicalORExpressionOrHigher = LogicalANDExpressionOrHigher | LogicalORExpression;
+    export interface LogicalORExpression extends BaseParseNode {
+        readonly type: 'LogicalORExpression';
+        readonly LogicalORExpression: LogicalORExpressionOrHigher;
+        readonly LogicalANDExpression: LogicalANDExpressionOrHigher;
+    }
+    export interface CoalesceExpression extends BaseParseNode {
+        readonly type: 'CoalesceExpression';
+        readonly CoalesceExpressionHead: CoalesceExpressionHead;
+        readonly BitwiseORExpression: BitwiseORExpressionOrHigher;
+    }
+    export type CoalesceExpressionHead = BitwiseORExpressionOrHigher | CoalesceExpression;
+    export type ShortCircuitExpressionOrHigher = LogicalORExpressionOrHigher | CoalesceExpression;
+    export type ConditionalExpressionOrHigher = ShortCircuitExpressionOrHigher | ConditionalExpression;
+    export interface ConditionalExpression extends BaseParseNode {
+        readonly type: 'ConditionalExpression';
+        readonly ShortCircuitExpression: ShortCircuitExpressionOrHigher;
+        readonly AssignmentExpression_a: AssignmentExpressionOrHigher;
+        readonly AssignmentExpression_b: AssignmentExpressionOrHigher;
+    }
+    export type AssignmentExpressionOrHigher = ConditionalExpressionOrHigher | YieldExpression | ArrowFunction | AsyncArrowFunction | AssignmentExpression;
+    export interface AssignmentExpression extends BaseParseNode {
+        readonly type: 'AssignmentExpression';
+        readonly LeftHandSideExpression: AssignmentExpressionOrHigher;
+        readonly AssignmentOperator: '=' | AssignmentOperator | '&&=' | '||=' | '??=';
+        readonly AssignmentExpression: AssignmentExpressionOrHigher;
+    }
+    export type AssignmentOperator = '*=' | '/=' | '%=' | '+=' | '-=' | '<<=' | '>>=' | '>>>=' | '&=' | '^=' | '|=' | '**=';
+    export interface AssignmentRestElement extends BaseParseNode {
+        readonly type: 'AssignmentRestElement';
+        readonly AssignmentExpression: AssignmentExpressionOrHigher;
+    }
+    export type BinaryExpressionOrHigher = BinaryExpression | UnaryExpressionOrHigher;
+    export type BinaryExpression = AssignmentExpression | LogicalORExpression | LogicalANDExpression | BitwiseORExpression | BitwiseXORExpression | BitwiseANDExpression | RelationalExpression | EqualityExpression | ShiftExpression | AdditiveExpression | MultiplicativeExpression | ExponentiationExpression;
+    export type Expression = CommaOperator | AssignmentExpressionOrHigher;
+    export interface CommaOperator extends BaseParseNode {
+        readonly type: 'CommaOperator';
+        readonly ExpressionList: readonly AssignmentExpressionOrHigher[];
+    }
+    export type Statement = BlockStatement | VariableStatement | EmptyStatement | ExpressionStatement | IfStatement | BreakableStatement | ContinueStatement | BreakStatement | ReturnStatement | WithStatement | LabelledStatement | ThrowStatement | TryStatement | DebuggerStatement;
+    export type Declaration = HoistableDeclaration | ClassDeclaration | LexicalDeclarationLike;
+    export type HoistableDeclaration = FunctionDeclaration | GeneratorDeclaration | AsyncFunctionDeclaration | AsyncGeneratorDeclaration;
+    export type BreakableStatement = IterationStatement | SwitchStatement;
+    export type BlockStatement = Block;
+    export interface Block extends BaseParseNode {
+        readonly type: 'Block';
+        readonly StatementList: StatementList;
+    }
+    export type StatementList = readonly StatementListItem[];
+    export type StatementListItem = Statement | Declaration;
+    export type LexicalDeclarationLike = LexicalDeclaration | UsingDeclaration | AwaitUsingDeclaration;
+    export interface LexicalDeclaration extends BaseParseNode {
+        readonly type: 'LexicalDeclaration';
+        readonly LetOrConst: LetOrConst;
+        readonly BindingList: BindingList;
+    }
+    export interface UsingDeclaration extends BaseParseNode {
+        readonly type: 'UsingDeclaration';
+        readonly BindingList: BindingList;
+    }
+    export interface AwaitUsingDeclaration extends BaseParseNode {
+        readonly type: 'AwaitUsingDeclaration';
+        readonly BindingList: BindingList;
+    }
+    export type LetOrConst = 'let' | 'const';
+    export type BindingList = readonly LexicalBinding[];
+    export interface LexicalBinding extends BaseParseNode {
+        readonly type: 'LexicalBinding';
+        readonly BindingIdentifier?: BindingIdentifier;
+        readonly BindingPattern?: BindingPattern;
+        readonly Initializer: Initializer | null;
+    }
+    export interface VariableStatement extends BaseParseNode {
+        readonly type: 'VariableStatement';
+        readonly VariableDeclarationList: VariableDeclarationList;
+    }
+    export type VariableDeclarationList = readonly VariableDeclaration[];
+    export interface VariableDeclaration extends BaseParseNode {
+        readonly type: 'VariableDeclaration';
+        readonly BindingPattern?: BindingPattern;
+        readonly BindingIdentifier?: BindingIdentifier;
+        readonly Initializer: Initializer | null;
+    }
+    export type BindingPattern = ObjectBindingPattern | ArrayBindingPattern;
+    export interface ObjectBindingPattern extends BaseParseNode {
+        readonly type: 'ObjectBindingPattern';
+        readonly BindingPropertyList: BindingPropertyList;
+        readonly BindingRestProperty?: BindingRestProperty;
+    }
+    export interface ArrayBindingPattern extends BaseParseNode {
+        readonly type: 'ArrayBindingPattern';
+        readonly BindingElementList: BindingElementList;
+        readonly BindingRestElement: BindingRestElement;
+    }
+    export interface BindingRestProperty extends BaseParseNode {
+        readonly type: 'BindingRestProperty';
+        readonly BindingIdentifier: BindingIdentifier;
+    }
+    export type BindingPropertyList = readonly BindingPropertyLike[];
+    export type BindingElementList = readonly BindingElisionElement[];
+    export type BindingElisionElement = BindingElementLike | Elision;
+    export type BindingPropertyLike = BindingProperty | SingleNameBinding;
+    export interface BindingProperty extends BaseParseNode {
+        readonly type: 'BindingProperty';
+        readonly PropertyName: PropertyNameLike;
+        readonly BindingElement: BindingElementLike;
+    }
+    export type BindingElementLike = BindingElement | SingleNameBinding;
+    export interface BindingElement extends BaseParseNode {
+        readonly type: 'BindingElement';
+        readonly BindingPattern: BindingPattern;
+        readonly Initializer: Initializer | null;
+    }
+    export interface SingleNameBinding extends BaseParseNode {
+        readonly type: 'SingleNameBinding';
+        readonly BindingIdentifier: BindingIdentifier;
+        readonly Initializer: Initializer | null;
+    }
+    export interface BindingRestElement extends BaseParseNode {
+        readonly type: 'BindingRestElement';
+        readonly BindingIdentifier?: BindingIdentifier;
+        readonly BindingPattern?: BindingPattern;
+    }
+    export interface EmptyStatement extends BaseParseNode {
+        readonly type: 'EmptyStatement';
+    }
+    export interface ExpressionStatement extends BaseParseNode {
+        readonly type: 'ExpressionStatement';
+        readonly Expression: Expression;
+    }
+    export interface IfStatement extends BaseParseNode {
+        readonly type: 'IfStatement';
+        readonly Expression: Expression;
+        readonly Statement_a: Statement;
+        readonly Statement_b: Statement;
+    }
+    export type IterationStatement = DoWhileStatement | WhileStatement | ForStatement | ForInOfStatement;
+    export interface DoWhileStatement extends BaseParseNode {
+        readonly type: 'DoWhileStatement';
+        readonly Statement: Statement;
+        readonly Expression: Expression;
+    }
+    export interface WhileStatement extends BaseParseNode {
+        readonly type: 'WhileStatement';
+        readonly Expression: Expression;
+        readonly Statement: Statement;
+    }
+    export interface ForStatement extends BaseParseNode {
+        readonly type: 'ForStatement';
+        readonly VariableDeclarationList: VariableDeclarationList;
+        readonly LexicalDeclaration?: LexicalDeclarationLike;
+        readonly Expression_a?: Expression;
+        readonly Expression_b?: Expression;
+        readonly Expression_c?: Expression;
+        readonly Statement: Statement;
+    }
+    export type ForInOfStatement = ForInStatement | ForOfStatement | ForAwaitStatement;
+    export interface ForInStatement extends BaseParseNode {
+        readonly type: 'ForInStatement';
+        readonly LeftHandSideExpression?: LeftHandSideExpression;
+        readonly ForBinding?: ForBinding;
+        readonly ForDeclaration?: ForDeclaration;
+        readonly Expression: Expression;
+        readonly Statement: Statement;
+    }
+    export interface ForOfStatement extends BaseParseNode {
+        readonly type: 'ForOfStatement';
+        readonly LeftHandSideExpression?: LeftHandSideExpression;
+        readonly ForDeclaration?: ForDeclaration;
+        readonly ForBinding?: ForBinding;
+        readonly AssignmentExpression: AssignmentExpressionOrHigher;
+        readonly Statement: Statement;
+    }
+    export interface ForAwaitStatement extends BaseParseNode {
+        readonly type: 'ForAwaitStatement';
+        readonly LeftHandSideExpression?: LeftHandSideExpression;
+        readonly ForDeclaration?: ForDeclaration;
+        readonly ForBinding?: ForBinding;
+        readonly AssignmentExpression: AssignmentExpressionOrHigher;
+        readonly Statement: Statement;
+    }
+    export type ForDeclaration = ForDeclaration_LetOrConst | ForDeclaration_Using | ForDeclaration_AwaitUsing;
+    export interface ForDeclaration_LetOrConst extends BaseParseNode {
+        readonly type: 'ForDeclaration';
+        readonly production: 'LetOrConst';
+        readonly LetOrConst: LetOrConst;
+        readonly ForBinding: ForBinding;
+    }
+    export interface ForDeclaration_Using extends BaseParseNode {
+        readonly type: 'ForDeclaration';
+        readonly production: 'Using';
+        readonly ForBinding: ForBinding;
+    }
+    export interface ForDeclaration_AwaitUsing extends BaseParseNode {
+        readonly type: 'ForDeclaration';
+        readonly production: 'AwaitUsing';
+        readonly ForBinding: ForBinding;
+    }
+    export interface ForBinding extends BaseParseNode {
+        readonly type: 'ForBinding';
+        readonly BindingIdentifier?: BindingIdentifier;
+        readonly BindingPattern?: BindingPattern;
+    }
+    export interface ContinueStatement extends BaseParseNode {
+        readonly type: 'ContinueStatement';
+        readonly LabelIdentifier: LabelIdentifier | null;
+    }
+    export interface BreakStatement extends BaseParseNode {
+        readonly type: 'BreakStatement';
+        readonly LabelIdentifier: LabelIdentifier | null;
+    }
+    export interface ReturnStatement extends BaseParseNode {
+        readonly type: 'ReturnStatement';
+        readonly Expression: Expression | null;
+    }
+    export interface WithStatement extends BaseParseNode {
+        readonly type: 'WithStatement';
+        readonly Expression: Expression;
+        readonly Statement: Statement;
+    }
+    export interface SwitchStatement extends BaseParseNode {
+        readonly type: 'SwitchStatement';
+        readonly Expression: Expression;
+        readonly CaseBlock: CaseBlock;
+    }
+    export interface CaseBlock extends BaseParseNode {
+        readonly type: 'CaseBlock';
+        readonly CaseClauses_a?: CaseClauses;
+        readonly DefaultClause?: DefaultClause;
+        readonly CaseClauses_b?: CaseClauses;
+    }
+    export type CaseClauses = readonly CaseClause[];
+    export interface CaseClause extends BaseParseNode {
+        readonly type: 'CaseClause';
+        readonly Expression: Expression;
+        readonly StatementList: StatementList;
+    }
+    export interface DefaultClause extends BaseParseNode {
+        readonly type: 'DefaultClause';
+        readonly StatementList: StatementList;
+    }
+    export interface LabelledStatement extends BaseParseNode {
+        readonly type: 'LabelledStatement';
+        readonly LabelIdentifier: LabelIdentifier;
+        readonly LabelledItem: LabelledItem;
+    }
+    export type LabelledItem = Statement | FunctionDeclaration;
+    export interface ThrowStatement extends BaseParseNode {
+        readonly type: 'ThrowStatement';
+        readonly Expression: Expression;
+    }
+    export interface TryStatement extends BaseParseNode {
+        readonly type: 'TryStatement';
+        readonly Block: Block;
+        readonly Catch: Catch | null;
+        readonly Finally: Finally | null;
+    }
+    export interface Catch extends BaseParseNode {
+        readonly type: 'Catch';
+        readonly CatchParameter: CatchParameter | null;
+        readonly Block: Block;
+    }
+    export type Finally = Block;
+    export type CatchParameter = BindingPattern | BindingIdentifier;
+    export interface DebuggerStatement extends BaseParseNode {
+        readonly type: 'DebuggerStatement';
+    }
+    export type UniqueFormalParameters = FormalParameters;
+    export type FormalParameters = readonly FormalParametersElement[];
+    export type FormalParametersElement = FormalParameterList[number] | FunctionRestParameter;
+    export type FormalParameterList = readonly FormalParameter[];
+    export type FunctionRestParameter = BindingRestElement;
+    export type FormalParameter = BindingElementLike;
+    export type FunctionLike = FunctionDeclarationLike | FunctionExpressionLike;
+    export type FunctionDeclarationLike = FunctionDeclaration | GeneratorDeclaration | AsyncFunctionDeclaration | AsyncGeneratorDeclaration;
+    export type FunctionExpressionLike = FunctionExpression | GeneratorExpression | AsyncFunctionExpression | AsyncGeneratorExpression;
+    export type FunctionBodyLike = FunctionBody | GeneratorBody | AsyncBody | AsyncGeneratorBody;
+    export interface FunctionDeclaration extends BaseParseNode {
+        readonly type: 'FunctionDeclaration';
+        readonly BindingIdentifier: BindingIdentifier | null;
+        readonly FormalParameters: FormalParameters;
+        readonly FunctionBody: FunctionBody;
+    }
+    export interface FunctionExpression extends BaseParseNode {
+        readonly type: 'FunctionExpression';
+        readonly BindingIdentifier: BindingIdentifier | null;
+        readonly FormalParameters: FormalParameters;
+        readonly FunctionBody: FunctionBody;
+    }
+    export interface FunctionBody extends BaseParseNode {
+        readonly type: 'FunctionBody';
+        readonly directives: string[];
+        readonly strict: boolean;
+        readonly FunctionStatementList: FunctionStatementList;
+    }
+    export type FunctionStatementList = StatementList;
+    export interface ArrowFunction extends BaseParseNode {
+        readonly type: 'ArrowFunction';
+        readonly ArrowParameters: ArrowParameters;
+        readonly ConciseBody: ConciseBodyLike;
+    }
+    export type ArrowParameters = ArrowFormalParameters;
+    export type ConciseBodyLike = FunctionBody | ConciseBody;
+    export interface ConciseBody extends BaseParseNode {
+        readonly type: 'ConciseBody';
+        readonly directives?: undefined;
+        readonly ExpressionBody: ExpressionBody;
+    }
+    export interface ExpressionBody extends BaseParseNode {
+        readonly type: 'ExpressionBody';
+        readonly AssignmentExpression: AssignmentExpressionOrHigher;
+    }
+    export type ArrowFormalParameters = UniqueFormalParameters;
+    export interface AsyncArrowFunction extends BaseParseNode {
+        readonly type: 'AsyncArrowFunction';
+        readonly ArrowParameters: ArrowParameters;
+        readonly AsyncConciseBody: AsyncConciseBodyLike;
+    }
+    export type AsyncConciseBodyLike = AsyncConciseBody | AsyncBody;
+    export interface AsyncConciseBody extends BaseParseNode {
+        readonly type: 'AsyncConciseBody';
+        readonly directives?: undefined;
+        readonly ExpressionBody: ExpressionBody;
+    }
+    export type MethodDefinitionLike = MethodDefinition | GeneratorMethod | AsyncMethod | AsyncGeneratorMethod;
+    export interface MethodDefinition extends BaseParseNode {
+        readonly type: 'MethodDefinition';
+        readonly Decorators?: readonly Decorator[] | null;
+        readonly static?: boolean;
+        readonly ClassElementName: ClassElementName;
+        readonly PropertySetParameterList: PropertySetParameterList | null;
+        readonly UniqueFormalParameters: UniqueFormalParameters | null;
+        readonly FunctionBody: FunctionBody;
+    }
+    export type PropertySetParameterList = [FormalParameter];
+    export interface GeneratorDeclaration extends BaseParseNode {
+        readonly type: 'GeneratorDeclaration';
+        readonly BindingIdentifier: BindingIdentifier | null;
+        readonly FormalParameters: FormalParameters;
+        readonly GeneratorBody: GeneratorBody;
+    }
+    export interface GeneratorExpression extends BaseParseNode {
+        readonly type: 'GeneratorExpression';
+        readonly BindingIdentifier: BindingIdentifier | null;
+        readonly FormalParameters: FormalParameters;
+        readonly GeneratorBody: GeneratorBody;
+    }
+    export interface GeneratorMethod extends BaseParseNode {
+        readonly type: 'GeneratorMethod';
+        readonly Decorators?: readonly Decorator[] | null;
+        readonly static?: boolean;
+        readonly ClassElementName: ClassElementName;
+        readonly PropertySetParameterList: null;
+        readonly UniqueFormalParameters: UniqueFormalParameters;
+        readonly GeneratorBody: GeneratorBody;
+    }
+    export interface GeneratorBody extends BaseParseNode {
+        readonly type: 'GeneratorBody';
+        readonly directives: string[];
+        readonly strict: boolean;
+        readonly FunctionStatementList: FunctionStatementList;
+    }
+    export interface YieldExpression extends BaseParseNode {
+        readonly type: 'YieldExpression';
+        readonly hasStar: boolean;
+        readonly AssignmentExpression: AssignmentExpressionOrHigher | null;
+    }
+    export interface AsyncGeneratorDeclaration extends BaseParseNode {
+        readonly type: 'AsyncGeneratorDeclaration';
+        readonly BindingIdentifier: BindingIdentifier | null;
+        readonly FormalParameters: FormalParameters;
+        readonly AsyncGeneratorBody: AsyncGeneratorBody;
+    }
+    export interface AsyncGeneratorExpression extends BaseParseNode {
+        readonly type: 'AsyncGeneratorExpression';
+        readonly BindingIdentifier: BindingIdentifier | null;
+        readonly FormalParameters: FormalParameters;
+        readonly AsyncGeneratorBody: AsyncGeneratorBody;
+    }
+    export interface AsyncGeneratorMethod extends BaseParseNode {
+        readonly type: 'AsyncGeneratorMethod';
+        readonly Decorators?: readonly Decorator[] | null;
+        readonly static?: boolean;
+        readonly ClassElementName: ClassElementName;
+        readonly PropertySetParameterList: null;
+        readonly UniqueFormalParameters: UniqueFormalParameters;
+        readonly AsyncGeneratorBody: AsyncGeneratorBody;
+    }
+    export interface AsyncGeneratorBody extends BaseParseNode {
+        readonly type: 'AsyncGeneratorBody';
+        readonly directives: string[];
+        readonly strict: boolean;
+        readonly FunctionStatementList: FunctionStatementList;
+    }
+    export interface AsyncFunctionDeclaration extends BaseParseNode {
+        readonly type: 'AsyncFunctionDeclaration';
+        readonly BindingIdentifier: BindingIdentifier | null;
+        readonly FormalParameters: FormalParameters;
+        readonly AsyncBody: AsyncBody;
+    }
+    export interface AsyncFunctionExpression extends BaseParseNode {
+        readonly type: 'AsyncFunctionExpression';
+        readonly BindingIdentifier: BindingIdentifier | null;
+        readonly FormalParameters: FormalParameters;
+        readonly AsyncBody: AsyncBody;
+    }
+    export interface AsyncMethod extends BaseParseNode {
+        readonly type: 'AsyncMethod';
+        readonly Decorators?: readonly Decorator[] | null;
+        readonly static?: boolean;
+        readonly ClassElementName: ClassElementName;
+        readonly PropertySetParameterList: null;
+        readonly UniqueFormalParameters: UniqueFormalParameters;
+        readonly AsyncBody: AsyncBody;
+    }
+    export interface AsyncBody extends BaseParseNode {
+        readonly type: 'AsyncBody';
+        readonly directives: string[];
+        readonly strict: boolean;
+        readonly FunctionStatementList: FunctionStatementList;
+    }
+    export interface AwaitExpression extends BaseParseNode {
+        readonly type: 'AwaitExpression';
+        readonly UnaryExpression: UnaryExpressionOrHigher;
+    }
+    export type ClassLike = ClassDeclaration | ClassExpression;
+    export type Decorator = Decorator_MemberExpression | Decorator_ParenthesizedExpression | Decorator_CallExpression;
+    export interface Decorator_MemberExpression extends BaseParseNode {
+        readonly type: 'Decorator';
+        readonly subtype: 'MemberExpression';
+        readonly MemberExpression: MemberExpression | IdentifierReference;
+        readonly ParenthesizedExpression?: undefined;
+        readonly CallExpression?: undefined;
+    }
+    export interface Decorator_ParenthesizedExpression extends BaseParseNode {
+        readonly type: 'Decorator';
+        readonly subtype: 'ParenthesizedExpression';
+        readonly ParenthesizedExpression: Expression;
+        readonly MemberExpression?: undefined;
+        readonly CallExpression?: undefined;
+    }
+    export interface Decorator_CallExpression extends BaseParseNode {
+        readonly type: 'Decorator';
+        readonly subtype: 'CallExpression';
+        readonly CallExpression: CallExpression;
+        readonly MemberExpression?: undefined;
+        readonly ParenthesizedExpression?: undefined;
+    }
+    export interface ClassDeclaration extends BaseParseNode {
+        readonly Decorators?: readonly Decorator[] | null;
+        readonly type: 'ClassDeclaration';
+        readonly BindingIdentifier: BindingIdentifier | null;
+        readonly ClassTail: ClassTail;
+    }
+    export interface ClassExpression extends BaseParseNode {
+        readonly Decorators?: readonly Decorator[] | null;
+        readonly type: 'ClassExpression';
+        readonly BindingIdentifier: BindingIdentifier | null;
+        readonly ClassTail: ClassTail;
+    }
+    export interface ClassTail extends BaseParseNode {
+        readonly type: 'ClassTail';
+        readonly ClassHeritage: ClassHeritage | null;
+        readonly ClassBody: ClassBody | null;
+    }
+    export type ClassHeritage = LeftHandSideExpression;
+    export type ClassBody = ClassElementList;
+    export type ClassElementList = readonly ClassElement[];
+    export type ClassElement = MethodDefinitionLike | FieldDefinition | ClassStaticBlock;
+    export interface FieldDefinition extends BaseParseNode {
+        readonly Decorators?: readonly Decorator[] | null;
+        readonly accessor?: boolean;
+        readonly type: 'FieldDefinition';
+        readonly static?: boolean;
+        readonly ClassElementName: ClassElementName;
+        readonly Initializer: Initializer | null;
+    }
+    export type ClassElementName = PropertyNameLike | PrivateIdentifier;
+    export interface ClassStaticBlock extends BaseParseNode {
+        readonly type: 'ClassStaticBlock';
+        readonly static: true;
+        readonly ClassStaticBlockBody: ClassStaticBlockBody;
+    }
+    export interface ClassStaticBlockBody extends BaseParseNode {
+        readonly type: 'ClassStaticBlockBody';
+        readonly ClassStaticBlockStatementList: ClassStaticBlockStatementList;
+    }
+    export type ClassStaticBlockStatementList = StatementList;
+    export interface Script extends BaseParseNode {
+        readonly type: 'Script';
+        readonly ScriptBody: ScriptBody | null;
+    }
+    export interface ScriptBody extends BaseParseNode {
+        readonly type: 'ScriptBody';
+        readonly StatementList: StatementList;
+    }
+    export interface Module extends BaseParseNode {
+        readonly type: 'Module';
+        readonly ModuleBody: ModuleBody | null;
+        readonly hasTopLevelAwait: boolean;
+    }
+    export interface ModuleBody extends BaseParseNode {
+        readonly type: 'ModuleBody';
+        readonly ModuleItemList: ModuleItemList;
+    }
+    export type ModuleItemList = readonly ModuleItem[];
+    export type ModuleItem = ImportDeclaration | ExportDeclaration | StatementListItem;
+    export type ModuleExportName = IdentifierName | StringLiteral;
+    export interface ImportDeclaration extends BaseParseNode {
+        readonly type: 'ImportDeclaration';
+        readonly ModuleSpecifier?: PrimaryExpression;
+        readonly Phase: 'source' | 'defer' | 'evaluation';
+        readonly ImportClause?: ImportClause;
+        readonly ImportedBinding?: ImportedBinding;
+        readonly FromClause?: FromClause;
+        readonly WithClause?: WithClause;
+    }
+    export interface ImportClause extends BaseParseNode {
+        readonly type: 'ImportClause';
+        readonly ImportedDefaultBinding?: ImportedDefaultBinding;
+        readonly NameSpaceImport?: NameSpaceImport;
+        readonly NamedImports?: NamedImports;
+    }
+    export interface ImportedDefaultBinding extends BaseParseNode {
+        readonly type: 'ImportedDefaultBinding';
+        readonly ImportedBinding: ImportedBinding;
+    }
+    export interface NameSpaceImport extends BaseParseNode {
+        readonly type: 'NameSpaceImport';
+        /** Present for `import { x, y } as ns from "mod"`. */
+        readonly NamedImports?: NamedImports;
+        readonly ImportedBinding: ImportedBinding;
+    }
+    export interface NamedImports extends BaseParseNode {
+        readonly type: 'NamedImports';
+        readonly ImportsList: ImportsList;
+    }
+    export type FromClause = ModuleSpecifier;
+    export type ImportsList = readonly ImportSpecifier[];
+    export interface ImportSpecifier extends BaseParseNode {
+        readonly type: 'ImportSpecifier';
+        readonly ModuleExportName?: ModuleExportName;
+        readonly ImportedBinding: ImportedBinding;
+    }
+    export type ModuleSpecifier = StringLiteral;
+    export type ImportedBinding = BindingIdentifier;
+    export interface WithClause extends BaseParseNode {
+        readonly type: 'WithClause';
+        readonly WithEntries: WithEntries;
+    }
+    export type WithEntries = readonly WithEntry[];
+    export interface WithEntry extends BaseParseNode {
+        readonly type: 'WithEntry';
+        readonly AttributeKey: AttributeKey;
+        readonly AttributeValue: StringLiteral;
+    }
+    export type AttributeKey = IdentifierName | StringLiteral;
+    export type ExportDeclaration = ExportDeclaration_Declaration | ExportDeclaration_DefaultClass | ExportDeclaration_DefaultDeclaration | ExportDeclaration_DefaultExpression | ExportDeclaration_NamedExports | ExportDeclaration_NamedFrom | ExportDeclaration_VariableStatement;
+    export interface ExportDeclaration_NamedFrom extends BaseParseNode {
+        readonly type: 'ExportDeclaration';
+        readonly ExportFromClause: ExportFromClauseLike;
+        readonly FromClause: FromClause;
+        readonly WithClause: undefined | WithClause;
+        readonly Phase: 'defer' | 'evaluation';
+        readonly AssignmentExpression?: undefined;
+        readonly ClassDeclaration?: undefined;
+        readonly Declaration?: null;
+        readonly Decorators?: null;
+        readonly default?: boolean;
+        readonly HoistableDeclaration?: undefined;
+        readonly NamedExports?: undefined;
+        readonly VariableStatement?: undefined;
+    }
+    export interface ExportDeclaration_NamedExports extends BaseParseNode {
+        readonly type: 'ExportDeclaration';
+        readonly NamedExports: NamedExports;
+        readonly AssignmentExpression?: undefined;
+        readonly ClassDeclaration?: undefined;
+        readonly Declaration?: null;
+        readonly Decorators?: null;
+        readonly default?: boolean;
+        readonly ExportFromClause?: undefined;
+        readonly FromClause?: undefined;
+        readonly HoistableDeclaration?: undefined;
+        readonly VariableStatement?: undefined;
+        readonly WithClause?: undefined;
+    }
+    export interface ExportDeclaration_VariableStatement extends BaseParseNode {
+        readonly type: 'ExportDeclaration';
+        readonly VariableStatement: VariableStatement;
+        readonly AssignmentExpression?: undefined;
+        readonly ClassDeclaration?: undefined;
+        readonly Declaration?: null;
+        readonly Decorators?: null;
+        readonly default?: boolean;
+        readonly ExportFromClause?: undefined;
+        readonly FromClause?: undefined;
+        readonly HoistableDeclaration?: undefined;
+        readonly NamedExports?: undefined;
+        readonly WithClause?: undefined;
+    }
+    export interface ExportDeclaration_Declaration extends BaseParseNode {
+        readonly type: 'ExportDeclaration';
+        readonly Decorators: readonly Decorator[] | null;
+        readonly Declaration: Declaration;
+        readonly AssignmentExpression?: undefined;
+        readonly ClassDeclaration?: undefined;
+        readonly default?: boolean;
+        readonly ExportFromClause?: undefined;
+        readonly FromClause?: undefined;
+        readonly HoistableDeclaration?: undefined;
+        readonly NamedExports?: undefined;
+        readonly VariableStatement?: undefined;
+        readonly WithClause?: undefined;
+    }
+    export interface ExportDeclaration_DefaultDeclaration extends BaseParseNode {
+        readonly type: 'ExportDeclaration';
+        readonly default: true;
+        readonly HoistableDeclaration: HoistableDeclaration;
+        readonly AssignmentExpression?: undefined;
+        readonly ClassDeclaration?: undefined;
+        readonly Declaration?: null;
+        readonly Decorators?: null;
+        readonly ExportFromClause?: undefined;
+        readonly FromClause?: undefined;
+        readonly NamedExports?: undefined;
+        readonly VariableStatement?: undefined;
+        readonly WithClause?: undefined;
+    }
+    export interface ExportDeclaration_DefaultClass extends BaseParseNode {
+        readonly type: 'ExportDeclaration';
+        readonly Decorators: readonly Decorator[] | null;
+        readonly default: true;
+        readonly ClassDeclaration: ClassDeclaration;
+        readonly AssignmentExpression?: undefined;
+        readonly Declaration?: null;
+        readonly ExportFromClause?: undefined;
+        readonly FromClause?: undefined;
+        readonly HoistableDeclaration?: undefined;
+        readonly NamedExports?: undefined;
+        readonly VariableStatement?: undefined;
+        readonly WithClause?: undefined;
+    }
+    export interface ExportDeclaration_DefaultExpression extends BaseParseNode {
+        readonly type: 'ExportDeclaration';
+        readonly default: true;
+        readonly AssignmentExpression: AssignmentExpressionOrHigher;
+        readonly ClassDeclaration?: undefined;
+        readonly Declaration?: null;
+        readonly Decorators?: null;
+        readonly ExportFromClause?: undefined;
+        readonly FromClause?: undefined;
+        readonly HoistableDeclaration?: undefined;
+        readonly NamedExports?: undefined;
+        readonly VariableStatement?: undefined;
+        readonly WithClause?: undefined;
+    }
+    export type ExportFromClauseLike = NamedExports | ExportFromClause;
+    export interface ExportFromClause extends BaseParseNode {
+        readonly type: 'ExportFromClause';
+        readonly ModuleExportName?: ModuleExportName;
+    }
+    export interface NamedExports extends BaseParseNode {
+        readonly type: 'NamedExports';
+        readonly ExportsList: ExportsList;
+        /** Present for `export { x, y } as ns from "mod"`. */
+        readonly NamespaceExportName?: ModuleExportName;
+    }
+    export type ExportsList = readonly ExportSpecifier[];
+    export interface ExportSpecifier extends BaseParseNode {
+        readonly type: 'ExportSpecifier';
+        readonly localName: ModuleExportName;
+        readonly exportName: ModuleExportName;
+    }
+    export type AssignmentPattern = ObjectAssignmentPattern | ArrayAssignmentPattern | AssignmentProperty | AssignmentElement | ParseNode.Elision;
+    export type ObjectAssignmentPattern = {
+        type: 'ObjectAssignmentPattern';
+        AssignmentPropertyList: (AssignmentProperty | AssignmentPattern)[];
+        AssignmentRestProperty: AssignmentRestProperty | undefined;
+    };
+    export type AssignmentProperty = {
+        type: 'AssignmentProperty';
+        IdentifierReference: ParseNode.IdentifierReference;
+        Initializer?: ParseNode.Initializer | null | undefined;
+    } | {
+        type: 'AssignmentProperty';
+        PropertyName: ParseNode.PropertyNameLike | null;
+        AssignmentElement: AssignmentElement;
+    };
+    export type AssignmentElement = {
+        type: 'AssignmentElement';
+        DestructuringAssignmentTarget: ParseNode.AssignmentExpressionOrHigher;
+        Initializer: ParseNode.Initializer | undefined | null;
+    };
+    export type ArrayAssignmentPattern = {
+        type: 'ArrayAssignmentPattern';
+        AssignmentElementList: AssignmentElisionElement[];
+        AssignmentRestElement: AssignmentRestElement | undefined;
+    };
+    export type AssignmentElisionElement = ParseNode.Elision | AssignmentElement | AssignmentPattern;
+    export type AssignmentRestProperty = {
+        type: 'AssignmentRestProperty';
+        DestructuringAssignmentTarget: ParseNode.AssignmentExpressionOrHigher;
+    };
+    type AllKeysOf<T> = T extends unknown ? keyof T : never;
+    type AllValuesOf<T, K extends AllKeysOf<T>> = T extends unknown ? K extends keyof T ? T[K] : never : never;
+    /**
+     * Used internally to describe a node that is still in the process of being parsed. Unfinished nodes may not yet be
+     * fully defined.
+     */
+    export type Unfinished<T extends ParseNode = ParseNode> = ({
+        type?: T['type'] & ParseNode['type'];
+        location: {
+            startIndex: number;
+            endIndex: number;
+            start: {
+                line: number;
+                column: number;
+            };
+            end: {
+                line: number;
+                column: number;
+            };
+        };
+        strict: boolean;
+        sourceText: string;
+    } & {
+        -readonly [K in Exclude<AllKeysOf<T>, 'location' | 'strict' | 'sourceText'>]?: AllValuesOf<T, K>;
+    });
+    /**
+     * Used internally to indicate a node that has finished parsing.
+     */
+    export type Finished<T extends BaseParseNode | Unfinished<ParseNode>, K extends T['type'] & ParseNode['type']> = T extends Unfinished<ParseNode> ? Extract<ParseNodesByType[K], T> : T;
+    export {};
+}
+export declare namespace ParseNode {
+    type WithStatementListChild = ModuleBody | ScriptBody | Block | CaseClause | DefaultClause | ClassStaticBlockBody | FunctionBody | GeneratorBody | AsyncBody | AsyncGeneratorBody;
+}
+/** https://tc39.es/ecma262/multipage/text-processing.html#sec-patterns */
+export declare namespace ParseNode.RegExp {
+    interface NodeWithPosition {
+        readonly position: number;
+    }
+    interface Pattern {
+        readonly type: 'Pattern';
+        readonly Disjunction: Disjunction;
+        readonly capturingGroups: readonly {
+            readonly GroupName: string | undefined;
+            readonly position: number;
+        }[];
+    }
+    interface Disjunction {
+        readonly type: 'Disjunction';
+        readonly Alternative: Alternative;
+        readonly Disjunction: Disjunction | undefined;
+    }
+    interface Alternative {
+        readonly type: 'Alternative';
+        readonly Term: readonly Term[];
+    }
+    type Term = Term_Assertion | Term_Atom;
+    interface Term_Assertion {
+        readonly type: 'Term';
+        readonly production: 'Assertion';
+        readonly Assertion: Assertion;
+    }
+    interface Term_Atom {
+        readonly type: 'Term';
+        readonly production: 'Atom';
+        readonly Atom: Atom;
+        readonly Quantifier: Quantifier | undefined;
+        readonly leftCapturingParenthesesBefore: number;
+        readonly capturingParenthesesWithin: number;
+    }
+    type Assertion = Assertion_Plain | Assertion_LookaheadOrLookbehind;
+    interface Assertion_Plain {
+        readonly type: 'Assertion';
+        readonly production: '^' | '$' | 'b' | 'B' | 'A' | 'z';
+    }
+    interface Assertion_LookaheadOrLookbehind {
+        readonly type: 'Assertion';
+        readonly production: '?=' | '?!' | '?<=' | '?<!';
+        readonly Disjunction: Disjunction;
+    }
+    interface Quantifier {
+        readonly type: 'Quantifier';
+        readonly QuantifierPrefix: QuantifierPrefix;
+        readonly QuestionMark: boolean;
+    }
+    type QuantifierPrefix = QuantifierPrefix_Plain | QuantifierPrefix_Count;
+    interface QuantifierPrefix_Plain {
+        readonly type: 'QuantifierPrefix';
+        readonly production: '*' | '+' | '?';
+    }
+    interface QuantifierPrefix_Count {
+        readonly type: 'QuantifierPrefix';
+        readonly production: '{}';
+        readonly DecimalDigits_a: number;
+        readonly DecimalDigits_b: number | undefined;
+    }
+    type Atom = Atom_PatternCharacter | Atom_Dot | Atom_AtomEscape | Atom_CharacterClass | Atom_Group | Atom_Modifier;
+    interface Atom_PatternCharacter {
+        readonly type: 'Atom';
+        readonly production: 'PatternCharacter';
+        readonly PatternCharacter: Character;
+    }
+    interface Atom_Dot {
+        readonly type: 'Atom';
+        readonly production: '.';
+    }
+    interface Atom_AtomEscape {
+        readonly type: 'Atom';
+        readonly production: 'AtomEscape';
+        readonly AtomEscape: AtomEscape;
+    }
+    interface Atom_CharacterClass {
+        readonly type: 'Atom';
+        readonly production: 'CharacterClass';
+        readonly CharacterClass: CharacterClass;
+    }
+    interface Atom_Group {
+        readonly type: 'Atom';
+        readonly production: 'Group';
+        readonly leftCapturingParenthesesBefore: number;
+        readonly GroupSpecifier: string | undefined;
+        readonly Disjunction: Disjunction;
+    }
+    interface Atom_Modifier {
+        readonly type: 'Atom';
+        readonly production: 'Modifier';
+        readonly leftCapturingParenthesesBefore: number;
+        readonly Disjunction: Disjunction;
+        readonly AddModifiers: RegularExpressionModifiers | undefined;
+        readonly RemoveModifiers: RegularExpressionModifiers | undefined;
+    }
+    type RegularExpressionModifier = 'i' | 'm' | 's';
+    type RegularExpressionModifiers = readonly RegularExpressionModifier[];
+    type AtomEscape = AtomEscape_DecimalEscape | AtomEscape_CharacterClassEscape | AtomEscape_CharacterEscape | AtomEscape_CaptureGroupName;
+    interface AtomEscape_DecimalEscape {
+        readonly type: 'AtomEscape';
+        readonly production: 'DecimalEscape';
+        readonly DecimalEscape: DecimalEscape;
+    }
+    interface AtomEscape_CharacterClassEscape {
+        readonly type: 'AtomEscape';
+        readonly production: 'CharacterClassEscape';
+        readonly CharacterClassEscape: CharacterClassEscape;
+    }
+    interface AtomEscape_CharacterEscape {
+        readonly type: 'AtomEscape';
+        readonly production: 'CharacterEscape';
+        readonly CharacterEscape: CharacterEscape;
+    }
+    interface AtomEscape_CaptureGroupName extends NodeWithPosition {
+        readonly type: 'AtomEscape';
+        readonly production: 'CaptureGroupName';
+        readonly GroupName: string;
+        readonly groupSpecifiersThatMatchSelf: readonly ParseNode.RegExp.Atom_Group[];
+    }
+    type CharacterEscape = CharacterEscape_ControlEscape | CharacterEscape_AsciiLetter | CharacterEscape_0 | CharacterEscape_HexEscapeSequence | CharacterEscape_RegExpUnicodeEscapeSequence | CharacterEscape_IdentityEscape;
+    interface CharacterEscape_ControlEscape {
+        readonly type: 'CharacterEscape';
+        readonly production: 'ControlEscape';
+        readonly ControlEscape: 'f' | 'n' | 'r' | 't' | 'v';
+    }
+    interface CharacterEscape_AsciiLetter {
+        readonly type: 'CharacterEscape';
+        readonly production: 'AsciiLetter';
+        readonly AsciiLetter: string;
+    }
+    interface CharacterEscape_0 {
+        readonly type: 'CharacterEscape';
+        readonly production: '0';
+    }
+    interface CharacterEscape_HexEscapeSequence {
+        readonly type: 'CharacterEscape';
+        readonly production: 'HexEscapeSequence';
+        readonly HexEscapeSequence: HexEscapeSequence;
+    }
+    interface CharacterEscape_RegExpUnicodeEscapeSequence {
+        readonly type: 'CharacterEscape';
+        readonly production: 'RegExpUnicodeEscapeSequence';
+        readonly RegExpUnicodeEscapeSequence: RegExpUnicodeEscapeSequence;
+    }
+    interface CharacterEscape_IdentityEscape {
+        readonly type: 'CharacterEscape';
+        readonly production: 'IdentityEscape';
+        readonly IdentityEscape: Character;
+    }
+    interface RegExpUnicodeEscapeSequence {
+        readonly type: 'RegExpUnicodeEscapeSequence';
+        readonly CodePoint?: number;
+        readonly HexLeadSurrogate?: number | undefined;
+        readonly HexTrailSurrogate?: number | undefined;
+        readonly Hex4Digits?: number | undefined;
+    }
+    interface DecimalEscape {
+        readonly type: 'DecimalEscape';
+        readonly position: number;
+        readonly value: number;
+    }
+    type CharacterClassEscape = CharacterClassEscape_Plain | CharacterClassEscape_UnicodePropertyValue;
+    interface CharacterClassEscape_Plain {
+        readonly type: 'CharacterClassEscape';
+        readonly production: 'd' | 'D' | 's' | 'S' | 'w' | 'W';
+    }
+    interface CharacterClassEscape_UnicodePropertyValue {
+        readonly type: 'CharacterClassEscape';
+        readonly production: 'p' | 'P';
+        readonly UnicodePropertyValueExpression: UnicodePropertyValueExpression;
+    }
+    type UnicodePropertyValueExpression = UnicodePropertyValueExpression_Eq | UnicodePropertyValueExpression_Lone;
+    interface UnicodePropertyValueExpression_Eq {
+        readonly type: 'UnicodePropertyValueExpression';
+        readonly production: '=';
+        readonly UnicodePropertyName: string;
+        readonly UnicodePropertyValue: string;
+    }
+    interface UnicodePropertyValueExpression_Lone {
+        readonly type: 'UnicodePropertyValueExpression';
+        readonly production: 'Lone';
+        readonly LoneUnicodePropertyNameOrValue: string;
+    }
+    interface CharacterClass {
+        readonly type: 'CharacterClass';
+        readonly invert: boolean;
+        readonly ClassContents: ClassContents;
+    }
+    type ClassContents = ClassContents_Empty | ClassContents_NonUnicodeSetMode | ClassContents_UnicodeSetMode;
+    interface ClassContents_Empty {
+        readonly type: 'ClassContents';
+        readonly production: 'Empty';
+    }
+    interface ClassContents_UnicodeSetMode {
+        readonly type: 'ClassContents';
+        readonly production: 'ClassSetExpression';
+        readonly ClassSetExpression: ClassSetExpression;
+    }
+    interface ClassContents_NonUnicodeSetMode {
+        readonly type: 'ClassContents';
+        readonly production: 'NonEmptyClassRanges';
+        readonly NonemptyClassRanges: NonEmptyClassRanges;
+    }
+    type NonEmptyClassRanges = readonly ClassRange[];
+    /** NON-SPEC */
+    type ClassRange = ClassAtom | readonly [start: ClassAtom, end: ClassAtom];
+    type ClassAtom = ClassAtom_Dash | ClassAtom_SourceCharacter | ClassAtom_ClassEscape;
+    interface ClassAtom_Dash {
+        readonly type: 'ClassAtom';
+        readonly production: '-';
+    }
+    interface ClassAtom_SourceCharacter {
+        readonly type: 'ClassAtom';
+        readonly production: 'SourceCharacter';
+        readonly SourceCharacter: string;
+    }
+    interface ClassAtom_ClassEscape {
+        readonly type: 'ClassAtom';
+        readonly production: 'ClassEscape';
+        readonly ClassEscape: ClassEscape;
+    }
+    type ClassEscape = ClassEscape_Plain | ClassEscape_CharacterClassEscape | ClassEscape_CharacterEscape;
+    interface ClassEscape_Plain {
+        readonly type: 'ClassEscape';
+        readonly production: 'b' | '-';
+    }
+    interface ClassEscape_CharacterClassEscape {
+        readonly type: 'ClassEscape';
+        readonly production: 'CharacterClassEscape';
+        readonly CharacterClassEscape: CharacterClassEscape;
+    }
+    interface ClassEscape_CharacterEscape {
+        readonly type: 'ClassEscape';
+        readonly production: 'CharacterEscape';
+        readonly CharacterEscape: CharacterEscape;
+    }
+    type ClassSetExpression = ClassUnion | ClassIntersection | ClassSubtraction;
+    interface ClassUnion {
+        readonly type: 'ClassUnion';
+        readonly union: readonly (ClassSetRange | ClassSetOperand)[];
+    }
+    interface ClassIntersection {
+        readonly type: 'ClassIntersection';
+        readonly operands: readonly ClassSetOperand[];
+    }
+    interface ClassSubtraction {
+        readonly type: 'ClassSubtraction';
+        readonly operands: readonly ClassSetOperand[];
+    }
+    interface ClassSetRange {
+        readonly type: 'ClassSetRange';
+        readonly left: ClassSetCharacter;
+        readonly right: ClassSetCharacter;
+    }
+    type ClassSetOperand = ClassSetOperand_NestedClass | ClassSetOperand_ClassStringDisjunction | ClassSetOperand_ClassSetCharacter;
+    interface ClassSetOperand_NestedClass {
+        readonly type: 'ClassSetOperand';
+        readonly production: 'NestedClass';
+        readonly NestedClass: NestedClass;
+    }
+    interface ClassSetOperand_ClassStringDisjunction {
+        readonly type: 'ClassSetOperand';
+        readonly production: 'ClassStringDisjunction';
+        readonly ClassStringDisjunction: ClassStringDisjunction;
+    }
+    interface ClassSetOperand_ClassSetCharacter {
+        readonly type: 'ClassSetOperand';
+        readonly production: 'ClassSetCharacter';
+        readonly ClassSetCharacter: ClassSetCharacter;
+    }
+    type NestedClass = NestedClass_ClassContents | NestedClass_CharacterClassEscape;
+    interface NestedClass_ClassContents {
+        readonly type: 'NestedClass';
+        readonly production: 'ClassContents';
+        readonly ClassContents: ClassContents;
+        readonly invert: boolean;
+    }
+    interface NestedClass_CharacterClassEscape {
+        readonly type: 'NestedClass';
+        readonly production: 'CharacterClassEscape';
+        readonly CharacterClassEscape: CharacterClassEscape;
+    }
+    interface ClassStringDisjunction {
+        readonly type: 'ClassStringDisjunction';
+        readonly ClassString: ClassSetCharacter[][];
+    }
+    type ClassString = string;
+    type ClassSetCharacter = ClassSetCharacter_UnicodeCharacter | ClassSetCharacter_CharacterEscape;
+    interface ClassSetCharacter_UnicodeCharacter {
+        readonly type: 'ClassSetCharacter';
+        readonly production: 'UnicodeCharacter';
+        readonly UnicodeCharacter: UnicodeCharacter;
+    }
+    interface ClassSetCharacter_CharacterEscape {
+        readonly type: 'ClassSetCharacter';
+        readonly production: 'CharacterEscape';
+        readonly CharacterEscape: CharacterEscape;
+    }
+    interface HexEscapeSequence {
+        readonly type: 'HexEscapeSequence';
+        readonly HexDigit_a: string;
+        readonly HexDigit_b: string;
+    }
+}
+export type ParseNode = ParseNode.PrivateIdentifier | ParseNode.IdentifierName | ParseNode.IdentifierReference | ParseNode.BindingIdentifier | ParseNode.LabelIdentifier | ParseNode.PropertyName | ParseNode.ThisExpression | ParseNode.NullLiteral | ParseNode.BooleanLiteral | ParseNode.NumericLiteral | ParseNode.StringLiteral | ParseNode.Elision | ParseNode.ArrayLiteral | ParseNode.SpreadElement | ParseNode.ObjectLiteral | ParseNode.PropertyDefinition | ParseNode.CoverInitializedName | ParseNode.MethodDefinition | ParseNode.FunctionDeclaration | ParseNode.FunctionExpression | ParseNode.FunctionBody | ParseNode.ArrowFunction | ParseNode.ExpressionBody | ParseNode.ConciseBody | ParseNode.GeneratorDeclaration | ParseNode.GeneratorExpression | ParseNode.GeneratorMethod | ParseNode.GeneratorBody | ParseNode.YieldExpression | ParseNode.AsyncGeneratorDeclaration | ParseNode.AsyncGeneratorExpression | ParseNode.AsyncGeneratorMethod | ParseNode.AsyncGeneratorBody | ParseNode.Decorator | ParseNode.ClassDeclaration | ParseNode.ClassExpression | ParseNode.ClassTail | ParseNode.FieldDefinition | ParseNode.ClassStaticBlock | ParseNode.ClassStaticBlockBody | ParseNode.AsyncFunctionDeclaration | ParseNode.AsyncFunctionExpression | ParseNode.AsyncMethod | ParseNode.AsyncBody | ParseNode.AsyncArrowFunction | ParseNode.AsyncConciseBody | ParseNode.RegularExpressionLiteral | ParseNode.CoverParenthesizedExpressionAndArrowParameterList | ParseNode.ParenthesizedExpression | ParseNode.SuperProperty | ParseNode.SuperProperty | ParseNode.NewTarget | ParseNode.ImportMeta | ParseNode.MemberExpression | ParseNode.NewExpression | ParseNode.SuperCall | ParseNode.ImportCall | ParseNode.CallExpression | ParseNode.TemplateLiteral | ParseNode.TaggedTemplateExpression | ParseNode.OptionalExpression | ParseNode.OptionalChain | ParseNode.AssignmentRestElement | ParseNode.UpdateExpression | ParseNode.AwaitExpression | ParseNode.UnaryExpression | ParseNode.ExponentiationExpression | ParseNode.MultiplicativeExpression | ParseNode.AdditiveExpression | ParseNode.ShiftExpression | ParseNode.RelationalExpression | ParseNode.EqualityExpression | ParseNode.BitwiseANDExpression | ParseNode.BitwiseXORExpression | ParseNode.BitwiseORExpression | ParseNode.LogicalANDExpression | ParseNode.LogicalORExpression | ParseNode.CoalesceExpression | ParseNode.ConditionalExpression | ParseNode.AssignmentExpression | ParseNode.CommaOperator | ParseNode.LexicalDeclaration | ParseNode.UsingDeclaration | ParseNode.AwaitUsingDeclaration | ParseNode.LexicalBinding | ParseNode.ObjectBindingPattern | ParseNode.ArrayBindingPattern | ParseNode.BindingRestProperty | ParseNode.BindingProperty | ParseNode.BindingRestElement | ParseNode.BindingElement | ParseNode.SingleNameBinding | ParseNode.Block | ParseNode.VariableStatement | ParseNode.VariableDeclaration | ParseNode.EmptyStatement | ParseNode.ExpressionStatement | ParseNode.IfStatement | ParseNode.DoWhileStatement | ParseNode.WhileStatement | ParseNode.ForStatement | ParseNode.ForInStatement | ParseNode.ForOfStatement | ParseNode.ForDeclaration | ParseNode.ForBinding | ParseNode.ForAwaitStatement | ParseNode.SwitchStatement | ParseNode.CaseBlock | ParseNode.CaseClause | ParseNode.DefaultClause | ParseNode.ContinueStatement | ParseNode.BreakStatement | ParseNode.ReturnStatement | ParseNode.WithStatement | ParseNode.LabelledStatement | ParseNode.ThrowStatement | ParseNode.TryStatement | ParseNode.Catch | ParseNode.DebuggerStatement | ParseNode.ImportDeclaration | ParseNode.ImportClause | ParseNode.ImportedDefaultBinding | ParseNode.NameSpaceImport | ParseNode.NamedImports | ParseNode.ImportSpecifier | ParseNode.WithClause | ParseNode.WithEntry | ParseNode.ExportDeclaration | ParseNode.ExportFromClause | ParseNode.NamedExports | ParseNode.ExportSpecifier | ParseNode.Script | ParseNode.ScriptBody | ParseNode.Module | ParseNode.ModuleBody;
+/**
+ * A type that contains a mapping of {@link ParseNode} type names to their corresponding {@link ParseNode} type.
+ *
+ * You can use `ParseNodesByType[T]` instead of a conditional type like `Extract<ParseNode, { type: T }>` which is often
+ * more expensive and can complicate assignability checks.
+ */
+export type ParseNodesByType = {
+    [N in ParseNode as N['type']]: N;
+};
+//# sourceMappingURL=ParseNode.d.mts.map