@gi-tcg/gts-transpiler 0.6.2 → 0.6.4

package/dist/index.d.ts

@@ -1,502 +1,9 @@
-import { Options, Parser } from "acorn";
+import * as acorn from "acorn";
+import { Options as Options$1, Parser as Parser$1 } from "acorn";
+import * as AST from "estree";
+import { Program, SourceLocation } from "estree";
 import { SourceMap } from "magic-string";
 
-//#region node_modules/@types/estree/index.d.ts
-// This definition file follows a somewhat unusual format. ESTree allows
-// runtime type checks based on the `type` parameter. In order to explain this
-// to typescript we want to use discriminated union types:
-// https://github.com/Microsoft/TypeScript/pull/9163
-//
-// For ESTree this is a bit tricky because the high level interfaces like
-// Node or Function are pulling double duty. We want to pass common fields down
-// to the interfaces that extend them (like Identifier or
-// ArrowFunctionExpression), but you can't extend a type union or enforce
-// common fields on them. So we've split the high level interfaces into two
-// types, a base type which passes down inherited fields, and a type union of
-// all types which extend the base type. Only the type union is exported, and
-// the union is how other types refer to the collection of inheriting types.
-//
-// This makes the definitions file here somewhat more difficult to maintain,
-// but it has the notable advantage of making ESTree much easier to use as
-// an end user.
-interface BaseNodeWithoutComments {
-  // Every leaf interface that extends BaseNode must specify a type property.
-  // The type property should be a string literal. For example, Identifier
-  // has: `type: "Identifier"`
-  type: string;
-  loc?: SourceLocation | null | undefined;
-  range?: [number, number] | undefined;
-}
-interface BaseNode extends BaseNodeWithoutComments {
-  leadingComments?: Comment[] | undefined;
-  trailingComments?: Comment[] | undefined;
-}
-interface Comment extends BaseNodeWithoutComments {
-  type: "Line" | "Block";
-  value: string;
-}
-interface SourceLocation {
-  source?: string | null | undefined;
-  start: Position;
-  end: Position;
-}
-interface Position {
-  /** >= 1 */
-  line: number;
-  /** >= 0 */
-  column: number;
-}
-interface Program extends BaseNode {
-  type: "Program";
-  sourceType: "script" | "module";
-  body: Array<Directive | Statement | ModuleDeclaration>;
-  comments?: Comment[] | undefined;
-}
-interface Directive extends BaseNode {
-  type: "ExpressionStatement";
-  expression: Literal;
-  directive: string;
-}
-interface BaseFunction extends BaseNode {
-  params: Pattern[];
-  generator?: boolean | undefined;
-  async?: boolean | undefined; // The body is either BlockStatement or Expression because arrow functions
-  // can have a body that's either. FunctionDeclarations and
-  // FunctionExpressions have only BlockStatement bodies.
-  body: BlockStatement | Expression;
-}
-type Statement = ExpressionStatement | BlockStatement | StaticBlock | EmptyStatement | DebuggerStatement | WithStatement | ReturnStatement | LabeledStatement | BreakStatement | ContinueStatement | IfStatement | SwitchStatement | ThrowStatement | TryStatement | WhileStatement | DoWhileStatement | ForStatement | ForInStatement | ForOfStatement | Declaration;
-interface BaseStatement extends BaseNode {}
-interface EmptyStatement extends BaseStatement {
-  type: "EmptyStatement";
-}
-interface BlockStatement extends BaseStatement {
-  type: "BlockStatement";
-  body: Statement[];
-  innerComments?: Comment[] | undefined;
-}
-interface StaticBlock extends Omit<BlockStatement, "type"> {
-  type: "StaticBlock";
-}
-interface ExpressionStatement extends BaseStatement {
-  type: "ExpressionStatement";
-  expression: Expression;
-}
-interface IfStatement extends BaseStatement {
-  type: "IfStatement";
-  test: Expression;
-  consequent: Statement;
-  alternate?: Statement | null | undefined;
-}
-interface LabeledStatement extends BaseStatement {
-  type: "LabeledStatement";
-  label: Identifier;
-  body: Statement;
-}
-interface BreakStatement extends BaseStatement {
-  type: "BreakStatement";
-  label?: Identifier | null | undefined;
-}
-interface ContinueStatement extends BaseStatement {
-  type: "ContinueStatement";
-  label?: Identifier | null | undefined;
-}
-interface WithStatement extends BaseStatement {
-  type: "WithStatement";
-  object: Expression;
-  body: Statement;
-}
-interface SwitchStatement extends BaseStatement {
-  type: "SwitchStatement";
-  discriminant: Expression;
-  cases: SwitchCase[];
-}
-interface ReturnStatement extends BaseStatement {
-  type: "ReturnStatement";
-  argument?: Expression | null | undefined;
-}
-interface ThrowStatement extends BaseStatement {
-  type: "ThrowStatement";
-  argument: Expression;
-}
-interface TryStatement extends BaseStatement {
-  type: "TryStatement";
-  block: BlockStatement;
-  handler?: CatchClause | null | undefined;
-  finalizer?: BlockStatement | null | undefined;
-}
-interface WhileStatement extends BaseStatement {
-  type: "WhileStatement";
-  test: Expression;
-  body: Statement;
-}
-interface DoWhileStatement extends BaseStatement {
-  type: "DoWhileStatement";
-  body: Statement;
-  test: Expression;
-}
-interface ForStatement extends BaseStatement {
-  type: "ForStatement";
-  init?: VariableDeclaration | Expression | null | undefined;
-  test?: Expression | null | undefined;
-  update?: Expression | null | undefined;
-  body: Statement;
-}
-interface BaseForXStatement extends BaseStatement {
-  left: VariableDeclaration | Pattern;
-  right: Expression;
-  body: Statement;
-}
-interface ForInStatement extends BaseForXStatement {
-  type: "ForInStatement";
-}
-interface DebuggerStatement extends BaseStatement {
-  type: "DebuggerStatement";
-}
-type Declaration = FunctionDeclaration | VariableDeclaration | ClassDeclaration;
-interface BaseDeclaration extends BaseStatement {}
-interface MaybeNamedFunctionDeclaration extends BaseFunction, BaseDeclaration {
-  type: "FunctionDeclaration";
-  /** It is null when a function declaration is a part of the `export default function` statement */
-  id: Identifier | null;
-  body: BlockStatement;
-}
-interface FunctionDeclaration extends MaybeNamedFunctionDeclaration {
-  id: Identifier;
-}
-interface VariableDeclaration extends BaseDeclaration {
-  type: "VariableDeclaration";
-  declarations: VariableDeclarator[];
-  kind: "var" | "let" | "const" | "using" | "await using";
-}
-interface VariableDeclarator extends BaseNode {
-  type: "VariableDeclarator";
-  id: Pattern;
-  init?: Expression | null | undefined;
-}
-interface ExpressionMap {
-  ArrayExpression: ArrayExpression;
-  ArrowFunctionExpression: ArrowFunctionExpression;
-  AssignmentExpression: AssignmentExpression;
-  AwaitExpression: AwaitExpression;
-  BinaryExpression: BinaryExpression;
-  CallExpression: CallExpression;
-  ChainExpression: ChainExpression;
-  ClassExpression: ClassExpression;
-  ConditionalExpression: ConditionalExpression;
-  FunctionExpression: FunctionExpression;
-  Identifier: Identifier;
-  ImportExpression: ImportExpression;
-  Literal: Literal;
-  LogicalExpression: LogicalExpression;
-  MemberExpression: MemberExpression;
-  MetaProperty: MetaProperty;
-  NewExpression: NewExpression;
-  ObjectExpression: ObjectExpression;
-  SequenceExpression: SequenceExpression;
-  TaggedTemplateExpression: TaggedTemplateExpression;
-  TemplateLiteral: TemplateLiteral;
-  ThisExpression: ThisExpression;
-  UnaryExpression: UnaryExpression;
-  UpdateExpression: UpdateExpression;
-  YieldExpression: YieldExpression;
-}
-type Expression = ExpressionMap[keyof ExpressionMap];
-interface BaseExpression extends BaseNode {}
-type ChainElement = SimpleCallExpression | MemberExpression;
-interface ChainExpression extends BaseExpression {
-  type: "ChainExpression";
-  expression: ChainElement;
-}
-interface ThisExpression extends BaseExpression {
-  type: "ThisExpression";
-}
-interface ArrayExpression extends BaseExpression {
-  type: "ArrayExpression";
-  elements: Array<Expression | SpreadElement | null>;
-}
-interface ObjectExpression extends BaseExpression {
-  type: "ObjectExpression";
-  properties: Array<Property | SpreadElement>;
-}
-interface PrivateIdentifier extends BaseNode {
-  type: "PrivateIdentifier";
-  name: string;
-}
-interface Property extends BaseNode {
-  type: "Property";
-  key: Expression;
-  value: Expression | Pattern; // Could be an AssignmentProperty
-  kind: "init" | "get" | "set";
-  method: boolean;
-  shorthand: boolean;
-  computed: boolean;
-}
-interface PropertyDefinition extends BaseNode {
-  type: "PropertyDefinition";
-  key: Expression | PrivateIdentifier;
-  value?: Expression | null | undefined;
-  computed: boolean;
-  static: boolean;
-}
-interface FunctionExpression extends BaseFunction, BaseExpression {
-  id?: Identifier | null | undefined;
-  type: "FunctionExpression";
-  body: BlockStatement;
-}
-interface SequenceExpression extends BaseExpression {
-  type: "SequenceExpression";
-  expressions: Expression[];
-}
-interface UnaryExpression extends BaseExpression {
-  type: "UnaryExpression";
-  operator: UnaryOperator;
-  prefix: true;
-  argument: Expression;
-}
-interface BinaryExpression extends BaseExpression {
-  type: "BinaryExpression";
-  operator: BinaryOperator;
-  left: Expression | PrivateIdentifier;
-  right: Expression;
-}
-interface AssignmentExpression extends BaseExpression {
-  type: "AssignmentExpression";
-  operator: AssignmentOperator;
-  left: Pattern | MemberExpression;
-  right: Expression;
-}
-interface UpdateExpression extends BaseExpression {
-  type: "UpdateExpression";
-  operator: UpdateOperator;
-  argument: Expression;
-  prefix: boolean;
-}
-interface LogicalExpression extends BaseExpression {
-  type: "LogicalExpression";
-  operator: LogicalOperator;
-  left: Expression;
-  right: Expression;
-}
-interface ConditionalExpression extends BaseExpression {
-  type: "ConditionalExpression";
-  test: Expression;
-  alternate: Expression;
-  consequent: Expression;
-}
-interface BaseCallExpression extends BaseExpression {
-  callee: Expression | Super;
-  arguments: Array<Expression | SpreadElement>;
-}
-type CallExpression = SimpleCallExpression | NewExpression;
-interface SimpleCallExpression extends BaseCallExpression {
-  type: "CallExpression";
-  optional: boolean;
-}
-interface NewExpression extends BaseCallExpression {
-  type: "NewExpression";
-}
-interface MemberExpression extends BaseExpression, BasePattern {
-  type: "MemberExpression";
-  object: Expression | Super;
-  property: Expression | PrivateIdentifier;
-  computed: boolean;
-  optional: boolean;
-}
-type Pattern = Identifier | ObjectPattern | ArrayPattern | RestElement | AssignmentPattern | MemberExpression;
-interface BasePattern extends BaseNode {}
-interface SwitchCase extends BaseNode {
-  type: "SwitchCase";
-  test?: Expression | null | undefined;
-  consequent: Statement[];
-}
-interface CatchClause extends BaseNode {
-  type: "CatchClause";
-  param: Pattern | null;
-  body: BlockStatement;
-}
-interface Identifier extends BaseNode, BaseExpression, BasePattern {
-  type: "Identifier";
-  name: string;
-}
-type Literal = SimpleLiteral | RegExpLiteral | BigIntLiteral;
-interface SimpleLiteral extends BaseNode, BaseExpression {
-  type: "Literal";
-  value: string | boolean | number | null;
-  raw?: string | undefined;
-}
-interface RegExpLiteral extends BaseNode, BaseExpression {
-  type: "Literal";
-  value?: RegExp | null | undefined;
-  regex: {
-    pattern: string;
-    flags: string;
-  };
-  raw?: string | undefined;
-}
-interface BigIntLiteral extends BaseNode, BaseExpression {
-  type: "Literal";
-  value?: bigint | null | undefined;
-  bigint: string;
-  raw?: string | undefined;
-}
-type UnaryOperator = "-" | "+" | "!" | "~" | "typeof" | "void" | "delete";
-type BinaryOperator = "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "<<" | ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "**" | "|" | "^" | "&" | "in" | "instanceof";
-type LogicalOperator = "||" | "&&" | "??";
-type AssignmentOperator = "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "**=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=" | "||=" | "&&=" | "??=";
-type UpdateOperator = "++" | "--";
-interface ForOfStatement extends BaseForXStatement {
-  type: "ForOfStatement";
-  await: boolean;
-}
-interface Super extends BaseNode {
-  type: "Super";
-}
-interface SpreadElement extends BaseNode {
-  type: "SpreadElement";
-  argument: Expression;
-}
-interface ArrowFunctionExpression extends BaseExpression, BaseFunction {
-  type: "ArrowFunctionExpression";
-  expression: boolean;
-  body: BlockStatement | Expression;
-}
-interface YieldExpression extends BaseExpression {
-  type: "YieldExpression";
-  argument?: Expression | null | undefined;
-  delegate: boolean;
-}
-interface TemplateLiteral extends BaseExpression {
-  type: "TemplateLiteral";
-  quasis: TemplateElement[];
-  expressions: Expression[];
-}
-interface TaggedTemplateExpression extends BaseExpression {
-  type: "TaggedTemplateExpression";
-  tag: Expression;
-  quasi: TemplateLiteral;
-}
-interface TemplateElement extends BaseNode {
-  type: "TemplateElement";
-  tail: boolean;
-  value: {
-    /** It is null when the template literal is tagged and the text has an invalid escape (e.g. - tag`\unicode and \u{55}`) */cooked?: string | null | undefined;
-    raw: string;
-  };
-}
-interface AssignmentProperty extends Property {
-  value: Pattern;
-  kind: "init";
-  method: boolean; // false
-}
-interface ObjectPattern extends BasePattern {
-  type: "ObjectPattern";
-  properties: Array<AssignmentProperty | RestElement>;
-}
-interface ArrayPattern extends BasePattern {
-  type: "ArrayPattern";
-  elements: Array<Pattern | null>;
-}
-interface RestElement extends BasePattern {
-  type: "RestElement";
-  argument: Pattern;
-}
-interface AssignmentPattern extends BasePattern {
-  type: "AssignmentPattern";
-  left: Pattern;
-  right: Expression;
-}
-interface BaseClass extends BaseNode {
-  superClass?: Expression | null | undefined;
-  body: ClassBody;
-}
-interface ClassBody extends BaseNode {
-  type: "ClassBody";
-  body: Array<MethodDefinition | PropertyDefinition | StaticBlock>;
-}
-interface MethodDefinition extends BaseNode {
-  type: "MethodDefinition";
-  key: Expression | PrivateIdentifier;
-  value: FunctionExpression;
-  kind: "constructor" | "method" | "get" | "set";
-  computed: boolean;
-  static: boolean;
-}
-interface MaybeNamedClassDeclaration extends BaseClass, BaseDeclaration {
-  type: "ClassDeclaration";
-  /** It is null when a class declaration is a part of the `export default class` statement */
-  id: Identifier | null;
-}
-interface ClassDeclaration extends MaybeNamedClassDeclaration {
-  id: Identifier;
-}
-interface ClassExpression extends BaseClass, BaseExpression {
-  type: "ClassExpression";
-  id?: Identifier | null | undefined;
-}
-interface MetaProperty extends BaseExpression {
-  type: "MetaProperty";
-  meta: Identifier;
-  property: Identifier;
-}
-type ModuleDeclaration = ImportDeclaration | ExportNamedDeclaration | ExportDefaultDeclaration | ExportAllDeclaration;
-interface BaseModuleDeclaration extends BaseNode {}
-interface BaseModuleSpecifier extends BaseNode {
-  local: Identifier;
-}
-interface ImportDeclaration extends BaseModuleDeclaration {
-  type: "ImportDeclaration";
-  specifiers: Array<ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier>;
-  attributes: ImportAttribute[];
-  source: Literal;
-}
-interface ImportSpecifier extends BaseModuleSpecifier {
-  type: "ImportSpecifier";
-  imported: Identifier | Literal;
-}
-interface ImportAttribute extends BaseNode {
-  type: "ImportAttribute";
-  key: Identifier | Literal;
-  value: Literal;
-}
-interface ImportExpression extends BaseExpression {
-  type: "ImportExpression";
-  source: Expression;
-  options?: Expression | null | undefined;
-}
-interface ImportDefaultSpecifier extends BaseModuleSpecifier {
-  type: "ImportDefaultSpecifier";
-}
-interface ImportNamespaceSpecifier extends BaseModuleSpecifier {
-  type: "ImportNamespaceSpecifier";
-}
-interface ExportNamedDeclaration extends BaseModuleDeclaration {
-  type: "ExportNamedDeclaration";
-  declaration?: Declaration | null | undefined;
-  specifiers: ExportSpecifier[];
-  attributes: ImportAttribute[];
-  source?: Literal | null | undefined;
-}
-interface ExportSpecifier extends Omit<BaseModuleSpecifier, "local"> {
-  type: "ExportSpecifier";
-  local: Identifier | Literal;
-  exported: Identifier | Literal;
-}
-interface ExportDefaultDeclaration extends BaseModuleDeclaration {
-  type: "ExportDefaultDeclaration";
-  declaration: MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration | Expression;
-}
-interface ExportAllDeclaration extends BaseModuleDeclaration {
-  type: "ExportAllDeclaration";
-  exported: Identifier | Literal | null;
-  attributes: ImportAttribute[];
-  source: Literal;
-}
-interface AwaitExpression extends BaseExpression {
-  type: "AwaitExpression";
-  argument: Expression;
-}
-//#endregion
 //#region src/parse/gts_plugin.d.ts
 interface GtsPluginOption {
   allowEmptyShortcutMember?: boolean;
@@ -505,7 +12,7 @@ interface GtsPluginOption {
 //#endregion
 //#region src/parse/index.d.ts
 interface ParseOptions extends GtsPluginOption {
-  onComment: Options["onComment"];
+  onComment: Options$1["onComment"];
 }
 declare function parse(input: string, options?: ParseOptions): Program;
 interface ParseLooseOptions extends GtsPluginOption {
@@ -609,6 +116,1380 @@ declare class GtsTranspilerError extends Error {
   constructor(message: string, position: SourceLocation | null);
 }
 //#endregion
+//#region src/types.d.ts
+type ForInit = boolean | "await";
+declare module "estree" {
+  interface Identifier {
+    isDummy?: boolean;
+  }
+  interface NodeMap {
+    GTSDefineStatement: GTSDefineStatement;
+    GTSNamedAttributeDefinition: GTSNamedAttributeDefinition;
+    GTSAttributeBody: GTSAttributeBody;
+    GTSPositionalAttributeList: GTSPositionalAttributeList;
+    GTSNamedAttributeBlock: GTSNamedAttributeBlock;
+    GTSDirectFunction: GTSDirectFunction;
+  }
+  interface ExpressionMap {
+    GTSShortcutArgumentExpression: GTSShortcutArgumentExpression;
+    GTSShortcutFunctionExpression: GTSShortcutFunctionExpression;
+  }
+  interface SimpleCallExpression {
+    lParenRange?: [number, number];
+  }
+  interface NewExpression {
+    lParenRange?: [number, number];
+  }
+  interface GTSDefineStatement extends BaseStatement {
+    type: "GTSDefineStatement";
+    body: GTSNamedAttributeDefinition;
+  }
+  interface GTSNamedAttributeDefinition extends BaseNode {
+    type: "GTSNamedAttributeDefinition";
+    name: Identifier | Literal;
+    body: GTSAttributeBody;
+    bindingAccessModifier?: "public" | "protected" | "private";
+    bindingName?: Identifier;
+  }
+  interface GTSAttributeBody extends BaseNode {
+    type: "GTSAttributeBody";
+    positionalAttributes: GTSPositionalAttributeList;
+    namedAttributes?: GTSNamedAttributeBlock;
+  }
+  interface GTSPositionalAttributeList extends BaseNode {
+    type: "GTSPositionalAttributeList";
+    attributes: Expression[];
+  }
+  interface GTSNamedAttributeBlock extends BaseNode {
+    type: "GTSNamedAttributeBlock";
+    attributes: GTSNamedAttributeDefinition[];
+    directAction?: GTSDirectFunction;
+  }
+  interface GTSDirectFunction extends BaseNode {
+    type: "GTSDirectFunction";
+    body: Statement[];
+  }
+  interface GTSShortcutArgumentExpression extends BaseExpression {
+    type: "GTSShortcutArgumentExpression";
+    property: Identifier;
+  }
+  interface GTSShortcutFunctionExpression extends BaseExpression {
+    type: "GTSShortcutFunctionExpression";
+    body: BlockStatement | Expression;
+    expression: boolean;
+  }
+}
+declare module "acorn" {
+  type ReadToken = Parse.Parser["readToken"];
+  const tokContexts: Parse.TokContexts;
+  class Position implements AST.Position {
+    line: number;
+    column: number;
+    constructor(line: number, column: number);
+  }
+  function isNewLine(code: number): boolean;
+  interface Parser {
+    readToken(...args: Parameters<ReadToken>): ReturnType<ReadToken>;
+  }
+}
+declare namespace Parse {
+  /**
+  * Destructuring errors object used during expression parsing
+  * See: https://github.com/acornjs/acorn/blob/main/acorn/src/parseutil.js
+  */
+  export interface DestructuringErrors {
+    shorthandAssign: number;
+    trailingComma: number;
+    parenthesizedAssign: number;
+    parenthesizedBind: number;
+    doubleProto: number;
+  }
+  /**
+  * Binding type constants used in checkLVal* and declareName
+  * to determine the type of a binding
+  */
+  export interface BindingType {
+    /** Not a binding */
+    BIND_NONE: 0;
+    /** Var-style binding */
+    BIND_VAR: 1;
+    /** Let- or const-style binding */
+    BIND_LEXICAL: 2;
+    /** Function declaration */
+    BIND_FUNCTION: 3;
+    /** Simple (identifier pattern) catch binding */
+    BIND_SIMPLE_CATCH: 4;
+    /** Special case for function names as bound inside the function */
+    BIND_OUTSIDE: 5;
+  }
+  export interface Options extends acorn.Options {}
+  export interface CommentMetaData {
+    containerId: number;
+    childIndex: number;
+    beforeMeaningfulChild: boolean;
+  }
+  /**
+  * Token context - controls how tokens are interpreted in different syntactic contexts
+  */
+  export interface TokContext {
+    token: string;
+    isExpr: boolean;
+    preserveSpace?: boolean;
+    override?: ((parser: Parser) => acorn.Token) | null;
+  }
+  /**
+  * Token type definition
+  */
+  export interface TokenType {
+    label: string;
+    keyword: string | undefined;
+    beforeExpr?: boolean;
+    startsExpr?: boolean;
+    isLoop?: boolean;
+    isAssign?: boolean;
+    prefix?: boolean;
+    postfix?: boolean;
+    binop?: number | null;
+    updateContext?: ((prevType: TokenType) => void) | null;
+  }
+  /**
+  * Acorn's built-in token contexts
+  */
+  export interface TokContexts {
+    /** Block statement context - `{` in statement position */
+    b_stat: TokContext & {
+      token: "{";
+    };
+    /** Block expression context - `{` in expression position (object literals) */
+    b_expr: TokContext & {
+      token: "{";
+    };
+    /** Template literal context - `${` inside template */
+    b_tmpl: TokContext & {
+      token: "${";
+    };
+    /** Parenthesized statement context - `(` in statement position */
+    p_stat: TokContext & {
+      token: "(";
+    };
+    /** Parenthesized expression context - `(` in expression position */
+    p_expr: TokContext & {
+      token: "(";
+    };
+    /** Quasi/template context - `` ` `` backtick */
+    q_tmpl: TokContext & {
+      token: "`";
+    };
+    /** Function statement context - `function` keyword in statement */
+    f_stat: TokContext & {
+      token: "function";
+    };
+    /** Function expression context - `function` keyword in expression */
+    f_expr: TokContext & {
+      token: "function";
+    };
+    /** Generator function expression context - `function*` in expression */
+    f_expr_gen: TokContext & {
+      token: "function";
+    };
+    /** Generator function context - `function*` in statement */
+    f_gen: TokContext & {
+      token: "function";
+    };
+  }
+  /**
+  * Acorn's built-in token types
+  */
+  export interface TokTypes {
+    num: TokenType & {
+      label: "num";
+    };
+    regexp: TokenType & {
+      label: "regexp";
+    };
+    string: TokenType & {
+      label: "string";
+    };
+    name: TokenType & {
+      label: "name";
+    };
+    privateId: TokenType & {
+      label: "privateId";
+    };
+    eof: TokenType & {
+      label: "eof";
+    };
+    bracketL: TokenType & {
+      label: "[";
+    };
+    bracketR: TokenType & {
+      label: "]";
+    };
+    braceL: TokenType & {
+      label: "{";
+    };
+    braceR: TokenType & {
+      label: "}";
+    };
+    parenL: TokenType & {
+      label: "(";
+    };
+    parenR: TokenType & {
+      label: ")";
+    };
+    comma: TokenType & {
+      label: ",";
+    };
+    semi: TokenType & {
+      label: ";";
+    };
+    colon: TokenType & {
+      label: ":";
+    };
+    dot: TokenType & {
+      label: ".";
+    };
+    question: TokenType & {
+      label: "?";
+    };
+    questionDot: TokenType & {
+      label: "?.";
+    };
+    arrow: TokenType & {
+      label: "=>";
+    };
+    template: TokenType & {
+      label: "template";
+    };
+    invalidTemplate: TokenType & {
+      label: "invalidTemplate";
+    };
+    ellipsis: TokenType & {
+      label: "...";
+    };
+    backQuote: TokenType & {
+      label: "`";
+    };
+    dollarBraceL: TokenType & {
+      label: "${";
+    };
+    eq: TokenType & {
+      label: "=";
+      isAssign: true;
+    };
+    assign: TokenType & {
+      label: "_=";
+      isAssign: true;
+    };
+    incDec: TokenType & {
+      label: "++/--";
+      prefix: true;
+      postfix: true;
+    };
+    prefix: TokenType & {
+      label: "!/~";
+      prefix: true;
+    };
+    logicalOR: TokenType & {
+      label: "||";
+      binop: 1;
+    };
+    logicalAND: TokenType & {
+      label: "&&";
+      binop: 2;
+    };
+    bitwiseOR: TokenType & {
+      label: "|";
+      binop: 3;
+    };
+    bitwiseXOR: TokenType & {
+      label: "^";
+      binop: 4;
+    };
+    bitwiseAND: TokenType & {
+      label: "&";
+      binop: 5;
+    };
+    equality: TokenType & {
+      label: "==/!=/===/!==";
+      binop: 6;
+    };
+    relational: TokenType & {
+      label: "</>/<=/>=";
+      binop: 7;
+    };
+    bitShift: TokenType & {
+      label: "<</>>/>>>";
+      binop: 8;
+    };
+    plusMin: TokenType & {
+      label: "+/-";
+      binop: 9;
+      prefix: true;
+    };
+    modulo: TokenType & {
+      label: "%";
+      binop: 10;
+    };
+    star: TokenType & {
+      label: "*";
+      binop: 10;
+    };
+    slash: TokenType & {
+      label: "/";
+      binop: 10;
+    };
+    starstar: TokenType & {
+      label: "**";
+    };
+    coalesce: TokenType & {
+      label: "??";
+      binop: 1;
+    };
+    _break: TokenType & {
+      label: "break";
+      keyword: "break";
+    };
+    _case: TokenType & {
+      label: "case";
+      keyword: "case";
+    };
+    _catch: TokenType & {
+      label: "catch";
+      keyword: "catch";
+    };
+    _continue: TokenType & {
+      label: "continue";
+      keyword: "continue";
+    };
+    _debugger: TokenType & {
+      label: "debugger";
+      keyword: "debugger";
+    };
+    _default: TokenType & {
+      label: "default";
+      keyword: "default";
+    };
+    _do: TokenType & {
+      label: "do";
+      keyword: "do";
+      isLoop: true;
+    };
+    _else: TokenType & {
+      label: "else";
+      keyword: "else";
+    };
+    _finally: TokenType & {
+      label: "finally";
+      keyword: "finally";
+    };
+    _for: TokenType & {
+      label: "for";
+      keyword: "for";
+      isLoop: true;
+    };
+    _function: TokenType & {
+      label: "function";
+      keyword: "function";
+    };
+    _if: TokenType & {
+      label: "if";
+      keyword: "if";
+    };
+    _return: TokenType & {
+      label: "return";
+      keyword: "return";
+    };
+    _switch: TokenType & {
+      label: "switch";
+      keyword: "switch";
+    };
+    _throw: TokenType & {
+      label: "throw";
+      keyword: "throw";
+    };
+    _try: TokenType & {
+      label: "try";
+      keyword: "try";
+    };
+    _var: TokenType & {
+      label: "var";
+      keyword: "var";
+    };
+    _const: TokenType & {
+      label: "const";
+      keyword: "const";
+    };
+    _while: TokenType & {
+      label: "while";
+      keyword: "while";
+      isLoop: true;
+    };
+    _with: TokenType & {
+      label: "with";
+      keyword: "with";
+    };
+    _new: TokenType & {
+      label: "new";
+      keyword: "new";
+    };
+    _this: TokenType & {
+      label: "this";
+      keyword: "this";
+    };
+    _super: TokenType & {
+      label: "super";
+      keyword: "super";
+    };
+    _class: TokenType & {
+      label: "class";
+      keyword: "class";
+    };
+    _extends: TokenType & {
+      label: "extends";
+      keyword: "extends";
+    };
+    _export: TokenType & {
+      label: "export";
+      keyword: "export";
+    };
+    _import: TokenType & {
+      label: "import";
+      keyword: "import";
+    };
+    _null: TokenType & {
+      label: "null";
+      keyword: "null";
+    };
+    _true: TokenType & {
+      label: "true";
+      keyword: "true";
+    };
+    _false: TokenType & {
+      label: "false";
+      keyword: "false";
+    };
+    _in: TokenType & {
+      label: "in";
+      keyword: "in";
+      binop: 7;
+    };
+    _instanceof: TokenType & {
+      label: "instanceof";
+      keyword: "instanceof";
+      binop: 7;
+    };
+    _typeof: TokenType & {
+      label: "typeof";
+      keyword: "typeof";
+      prefix: true;
+    };
+    _void: TokenType & {
+      label: "void";
+      keyword: "void";
+      prefix: true;
+    };
+    _delete: TokenType & {
+      label: "delete";
+      keyword: "delete";
+      prefix: true;
+    };
+  }
+  /**
+  * TypeScript-specific token types added by @sveltejs/acorn-typescript
+  */
+  export interface AcornTypeScriptTokTypes {
+    jsxTagStart: TokenType & {
+      label: "jsxTagStart";
+    };
+    jsxTagEnd: TokenType & {
+      label: "jsxTagEnd";
+    };
+    jsxText: TokenType & {
+      label: "jsxText";
+    };
+    jsxName: TokenType & {
+      label: "jsxName";
+    };
+    at: TokenType & {
+      label: "@";
+    };
+    abstract: TokenType & {
+      label: "abstract";
+    };
+    as: TokenType & {
+      label: "as";
+    };
+    asserts: TokenType & {
+      label: "asserts";
+    };
+    assert: TokenType & {
+      label: "assert";
+    };
+    bigint: TokenType & {
+      label: "bigint";
+    };
+    declare: TokenType & {
+      label: "declare";
+    };
+    enum: TokenType & {
+      label: "enum";
+    };
+    global: TokenType & {
+      label: "global";
+    };
+    implements: TokenType & {
+      label: "implements";
+    };
+    infer: TokenType & {
+      label: "infer";
+    };
+    interface: TokenType & {
+      label: "interface";
+    };
+    intrinsic: TokenType & {
+      label: "intrinsic";
+    };
+    is: TokenType & {
+      label: "is";
+    };
+    keyof: TokenType & {
+      label: "keyof";
+    };
+    module: TokenType & {
+      label: "module";
+    };
+    namespace: TokenType & {
+      label: "namespace";
+    };
+    never: TokenType & {
+      label: "never";
+    };
+    out: TokenType & {
+      label: "out";
+    };
+    override: TokenType & {
+      label: "override";
+    };
+    private: TokenType & {
+      label: "private";
+    };
+    protected: TokenType & {
+      label: "protected";
+    };
+    public: TokenType & {
+      label: "public";
+    };
+    readonly: TokenType & {
+      label: "readonly";
+    };
+    require: TokenType & {
+      label: "require";
+    };
+    satisfies: TokenType & {
+      label: "satisfies";
+    };
+    symbol: TokenType & {
+      label: "symbol";
+    };
+    type: TokenType & {
+      label: "type";
+    };
+    unique: TokenType & {
+      label: "unique";
+    };
+    unknown: TokenType & {
+      label: "unknown";
+    };
+  }
+  /**
+  * TypeScript-specific token contexts added by @sveltejs/acorn-typescript
+  */
+  export interface AcornTypeScriptTokContexts {
+    /** JSX opening tag context - `<` starting a JSX tag */
+    tc_oTag: TokContext & {
+      token: "<";
+    };
+    /** JSX closing tag context - `</` closing a JSX tag */
+    tc_cTag: TokContext & {
+      token: "</";
+    };
+    /** JSX expression context - `{` inside JSX for expressions */
+    tc_expr: TokContext & {
+      token: "{";
+    };
+  }
+  /**
+  * Combined TypeScript extensions object
+  */
+  export interface AcornTypeScriptExtensions {
+    tokTypes: AcornTypeScriptTokTypes;
+    tokContexts: AcornTypeScriptTokContexts;
+  }
+  /**
+  * Extended Parser instance with internal properties
+  *
+  * These properties are used internally by Acorn but not exposed in official types.
+  * They are accessed by Ripple's custom parser plugin for whitespace handling,
+  * JSX parsing, and other advanced features.
+  */
+  export class Parser extends acorn.Parser {
+    /** Start position of the current token (0-indexed) */
+    start: number;
+    /** End position of the current token (0-indexed) */
+    end: number;
+    /** Current parsing position in input string (0-indexed) */
+    pos: number;
+    /** Current line number (1-indexed) */
+    curLine: number;
+    /** Position where the current line starts (0-indexed) */
+    lineStart: number;
+    /** Start location of current token */
+    startLoc: AST.Position;
+    /** End location of current token */
+    endLoc: AST.Position;
+    /** End position of the last token */
+    lastTokEnd: number;
+    /** Start position of the last token */
+    lastTokStart: number;
+    /** End location of the last token */
+    lastTokEndLoc: AST.Position;
+    /** Start location of the last token */
+    lastTokStartLoc: AST.Position;
+    /** Current token type */
+    type: TokenType;
+    /** Current token value (string for names, number for nums, etc.) */
+    value: string | number | RegExp | bigint | null;
+    /** The source code being parsed */
+    input: string;
+    /** Whether the current position expects an expression */
+    exprAllowed: boolean;
+    /** Whether the parser is in strict mode */
+    strict: boolean;
+    /** Whether we're inside a generator function */
+    inGenerator: boolean;
+    /** Whether we're inside an async function */
+    inAsync: boolean;
+    /** Whether we're inside a function */
+    inFunction: boolean;
+    /** Stack of label names for break/continue statements */
+    labels: Array<{
+      kind: string | null;
+      name?: string;
+      statementStart?: number;
+    }>;
+    /** Current scope flags stack */
+    scopeStack: Array<{
+      flags: number;
+      var: string[];
+      lexical: string[];
+      functions: string[];
+    }>;
+    /** Regular expression validation state */
+    regexpState?: any;
+    /** Whether we can use await keyword */
+    canAwait: boolean;
+    /** Position of await keyword (0 if not in async context) */
+    awaitPos: number;
+    /** Position of yield keyword (0 if not in generator context) */
+    yieldPos: number;
+    /** Position of await used as identifier (for error reporting) */
+    awaitIdentPos: number;
+    /** Whether current identifier contains escape sequences */
+    containsEsc: boolean;
+    /** Potential arrow function position */
+    potentialArrowAt: number;
+    /** Potential arrow in for-await position */
+    potentialArrowInForAwait: boolean;
+    /** Private name stack for class private fields validation */
+    privateNameStack: Array<{
+      declared: Record<string, any>;
+      used: Array<AST.Node>;
+    }>;
+    /** Undefined exports for module validation */
+    undefinedExports: Record<string, AST.Node>;
+    /** Token context stack for tokenizer state */
+    context: TokContext[];
+    /** Whether to preserve spaces in current context */
+    preserveSpace?: boolean;
+    /** Parser options (from constructor) */
+    options: Options;
+    /** ECMAScript version being parsed */
+    ecmaVersion: number;
+    /** Keywords regex for current ecmaVersion */
+    keywords: RegExp;
+    /** Reserved words regex */
+    reservedWords: RegExp;
+    /** Whether we're parsing a module */
+    inModule: boolean;
+    /**
+    * Finish current token with given type and optional value
+    * @see https://github.com/acornjs/acorn/blob/main/acorn/src/tokenize.js
+    */
+    finishToken(type: TokenType, val?: string | number | RegExp | bigint): void;
+    readAtIdentifier(): void;
+    /**
+    * Read a token based on character code
+    * Called by nextToken() for each character
+    */
+    readToken(code: number): void;
+    /**
+    * Read a word (identifier or keyword)
+    * @returns Token type (name or keyword)
+    */
+    readWord(): TokenType;
+    /**
+    * Read word starting from current position
+    * @returns The word string
+    */
+    readWord1(): string;
+    /** Read a number literal */
+    readNumber(startsWithDot: boolean): void;
+    /** Read a string literal */
+    readString(quote: number): void;
+    /** Read a template token */
+    readTmplToken(): void;
+    /** Read a regular expression literal */
+    readRegexp(): void;
+    /** Skip block comment, tracking line positions */
+    skipBlockComment(): void;
+    /** Skip line comment */
+    skipLineComment(startSkip: number): void;
+    /** Skip whitespace and comments */
+    skipSpace(): void;
+    /** Read and return the next token */
+    nextToken(): void;
+    /** Advance to next token (wrapper around nextToken) */
+    next(): void;
+    /**
+    * Get token from character code
+    * Main tokenizer dispatch based on first character
+    */
+    getTokenFromCode(code: number): void;
+    /**
+    * Get current position as Position object
+    * @returns { line: number, column: number, index: number }
+    */
+    curPosition(): AST.Position;
+    /**
+    * Finish building an operator token
+    * @param type Token type
+    * @param size Number of characters consumed
+    */
+    finishOp(type: TokenType, size: number): TokenType;
+    /**
+    * Finish a node, setting its end position and type
+    * @template T Node type extending AST.Node
+    * @param node The node to finish
+    * @param type The node type string (e.g., "Identifier", "BinaryExpression")
+    * @returns The finished node
+    */
+    finishNode<T extends AST.Node>(node: T, type: string): T;
+    /**
+    * Finish a node at a specific position
+    */
+    finishNodeAt<T extends AST.Node>(node: T, type: string, pos: number, loc: AST.Position): T;
+    /**
+    * Start a new node at current position
+    */
+    startNode(): AST.Node;
+    /**
+    * Start a new node at a specific position
+    * @param pos Start position
+    * @param loc Start location
+    * @returns A new node with specified start position
+    */
+    startNodeAt(pos: number, loc: AST.Position): AST.Node;
+    /**
+    * Start a node at the same position as another node
+    * @param node The node to copy position from
+    * @returns A new node with copied start position
+    */
+    startNodeAtNode(node: AST.Node): AST.Node;
+    /**
+    * Copy a node's position info
+    * @template T Node type
+    * @param node The node to copy
+    * @returns A shallow copy of the node
+    */
+    copyNode<T extends AST.Node>(node: T): T;
+    /**
+    * Reset end location from another node
+    * @param node Node to update
+    */
+    resetEndLocation(node: AST.Node): void;
+    /**
+    * Reset start location from another node
+    * @param node Node to update
+    * @param locationNode Node to copy from
+    */
+    resetStartLocationFromNode(node: AST.Node, locationNode: AST.Node): void;
+    /**
+    * Raise a fatal error at given position
+    * @throws SyntaxError
+    */
+    raise(pos: number, message: string): never;
+    /**
+    * Raise a recoverable error (warning that doesn't stop parsing)
+    */
+    raiseRecoverable(pos: number, message: string): void;
+    /**
+    * Throw unexpected token error
+    * @param pos Optional position (defaults to current)
+    */
+    unexpected(pos?: number): never;
+    /**
+    * Expect a specific token type, raise error if not found
+    * @param type Expected token type
+    */
+    expect(type: TokenType): void;
+    /**
+    * Consume token if it matches, return true if consumed
+    * @param type Token type to eat
+    * @returns true if token was consumed
+    */
+    eat(type: TokenType): boolean;
+    /**
+    * Check if current token matches type (alias for this.type === type)
+    * @param type Token type to match
+    */
+    match(type: TokenType): boolean;
+    /**
+    * Peek at character at position
+    * @deprecated Use charCodeAt instead
+    */
+    charAt(pos: number): string;
+    /**
+    * Get character code at position in input
+    */
+    charCodeAt(pos: number): number;
+    /**
+    * Check if current token is a contextual keyword
+    * @param name Keyword to check (e.g., "async", "of")
+    */
+    isContextual(name: string): boolean;
+    /**
+    * Consume if current token is a contextual keyword
+    * @param name Keyword to consume
+    * @returns true if consumed
+    */
+    eatContextual(name: string): boolean;
+    /**
+    * Expect a contextual keyword, raise error if not found
+    * @param name Expected keyword
+    */
+    expectContextual(name: string): void;
+    /**
+    * Check if semicolon can be inserted at current position (ASI)
+    */
+    canInsertSemicolon(): boolean;
+    /**
+    * Insert a semicolon if allowed by ASI rules
+    * returns true if semicolon was inserted
+    */
+    insertSemicolon(): boolean;
+    /**
+    * Consume semicolon or insert via ASI
+    */
+    semicolon(): void;
+    /**
+    * Handle trailing comma in lists
+    */
+    afterTrailingComma(type: TokenType, notNext?: boolean): boolean;
+    /**
+    * Enter a new scope
+    * @param flags Scope flags (SCOPE_* constants)
+    */
+    enterScope(flags: number): void;
+    /** Exit current scope */
+    exitScope(): void;
+    /**
+    * Declare a name in current scope
+    */
+    declareName(name: string, bindingType: BindingType[keyof BindingType], pos: number): void;
+    /** Get current scope */
+    currentScope(): {
+      flags: number;
+      var: string[];
+      lexical: string[];
+      functions: string[];
+    };
+    /** Get current variable scope (for var declarations) */
+    currentVarScope(): {
+      flags: number;
+      var: string[];
+      lexical: string[];
+      functions: string[];
+    };
+    /** Get current "this" scope */
+    currentThisScope(): {
+      flags: number;
+      var: string[];
+      lexical: string[];
+      functions: string[];
+    };
+    /** Check if treating functions as var in current scope */
+    treatFunctionsAsVarInScope(scope: any): boolean;
+    /**
+    * Get current token context
+    * @returns Current context from stack
+    */
+    curContext(): TokContext;
+    /**
+    * Update token context based on previous token
+    * @param prevType Previous token type
+    */
+    updateContext(prevType: TokenType): void;
+    /**
+    * Override the current context
+    * @param context New context to push
+    */
+    overrideContext(context: TokContext): void;
+    /**
+    * Look ahead one token without consuming
+    * @returns Object with type and value of next token
+    */
+    lookahead(): {
+      type: TokenType;
+      value: any;
+    };
+    /**
+    * Get next token start position
+    */
+    nextTokenStart(): number;
+    /**
+    * Get next token start since given position
+    */
+    nextTokenStartSince(pos: number): number;
+    /**
+    * Look ahead at character code
+    */
+    lookaheadCharCode(): number;
+    /**
+    * Parse an expression
+    */
+    parseExpression(forInit?: ForInit, refDestructuringErrors?: DestructuringErrors): AST.Expression;
+    /**
+    * Parse maybe-assignment expression (handles = and op=)
+    */
+    parseMaybeAssign(forInit?: ForInit, refDestructuringErrors?: DestructuringErrors, afterLeftParse?: (node: AST.Node, startPos: number, startLoc: AST.Position) => AST.Node): AST.Expression;
+    /**
+    * Parse maybe-conditional expression (?:)
+    */
+    parseMaybeConditional(forInit?: ForInit, refDestructuringErrors?: DestructuringErrors): AST.Expression;
+    /**
+    * Parse expression with operators (handles precedence)
+    */
+    parseExprOps(forInit?: ForInit, refDestructuringErrors?: DestructuringErrors): AST.Expression;
+    /**
+    * Parse expression with operator at given precedence
+    */
+    parseExprOp(left: AST.Expression, leftStartPos: number, leftStartLoc: AST.Position, minPrec: number, forInit?: ForInit): AST.Expression;
+    /**
+    * Parse maybe-unary expression (prefix operators)
+    */
+    parseMaybeUnary(refDestructuringErrors?: DestructuringErrors | null, sawUnary?: boolean, incDec?: boolean, forInit?: ForInit): AST.Expression;
+    /**
+    * Parse expression subscripts (member access, calls)
+    */
+    parseExprSubscripts(refDestructuringErrors?: DestructuringErrors, forInit?: ForInit): AST.Expression;
+    /**
+    * Parse subscripts (., [], (), ?.)
+    */
+    parseSubscripts(base: AST.Expression, startPos: number, startLoc: AST.Position, noCalls?: boolean, forInit?: ForInit): AST.Expression;
+    parseSubscript(base: AST.Expression, startPos: number, startLoc: AST.Position, noCalls?: boolean, maybeAsyncArrow?: boolean, optionalChained?: boolean, forInit?: ForInit): AST.Expression;
+    /**
+    * Parse expression atom (literals, identifiers, etc.)
+    */
+    parseExprAtom(refDestructuringErrors?: DestructuringErrors, forInit?: ForInit, forNew?: boolean): AST.Expression;
+    /**
+    * Parse a literal value (string, number, boolean, null, regex)
+    * @param value The literal value
+    * @returns Literal node
+    */
+    parseLiteral(value: string | number | boolean | null | RegExp | bigint): AST.Literal;
+    /**
+    * Parse parenthesized expression, distinguishing arrow functions
+    */
+    parseParenAndDistinguishExpression(canBeArrow?: boolean, forInit?: ForInit): AST.Expression;
+    /** Parse parenthesized expression (just the expression) */
+    parseParenExpression(): AST.Expression;
+    /**
+    * Parse item in parentheses (can be overridden for flow/ts)
+    */
+    parseParenItem(item: AST.Node): AST.Node;
+    /**
+    * Parse arrow expression
+    
+    */
+    parseArrowExpression(node: AST.Node, params: AST.Node[], isAsync?: boolean, forInit?: ForInit): AST.ArrowFunctionExpression;
+    /**
+    * Check if arrow should be parsed
+    */
+    shouldParseArrow(exprList: AST.Node[]): boolean;
+    /**
+    * Parse spread element (...expr)
+    */
+    parseSpread(refDestructuringErrors?: DestructuringErrors): AST.SpreadElement;
+    /**
+    * Parse rest binding pattern (...pattern)
+    * @returns RestElement node
+    */
+    parseRestBinding(): AST.RestElement;
+    /**
+    * Parse 'new' expression
+    * @returns NewExpression or MetaProperty (new.target)
+    */
+    parseNew(): AST.NewExpression | AST.MetaProperty;
+    /**
+    * Parse dynamic import expression
+    * @param forNew Whether in new expression context
+    */
+    parseExprImport(forNew?: boolean): AST.ImportExpression | AST.MetaProperty;
+    /**
+    * Parse dynamic import call
+    * @param node Import expression node
+    */
+    parseDynamicImport(node: AST.Node): AST.ImportExpression;
+    /**
+    * Parse import.meta
+    * @param node MetaProperty node
+    */
+    parseImportMeta(node: AST.Node): AST.MetaProperty;
+    /** Parse yield expression */
+    parseYield(forInit?: ForInit): AST.YieldExpression;
+    /** Parse await expression */
+    parseAwait(forInit?: ForInit): AST.AwaitExpression;
+    /**
+    * Parse template literal
+    * @param isTagged Whether this is a tagged template
+    */
+    parseTemplate(isTagged?: {
+      start: number;
+    }): AST.TemplateLiteral;
+    /**
+    * Parse template element
+    * @param options { isTagged: boolean }
+    */
+    parseTemplateElement(options: {
+      isTagged: boolean;
+    }): AST.TemplateElement;
+    /**
+    * Parse an identifier
+    */
+    parseIdent(liberal?: boolean): AST.Identifier;
+    /**
+    * Parse identifier node (internal, doesn't consume token)
+    * @returns Partial identifier node
+    */
+    parseIdentNode(): AST.Node;
+    /**
+    * Parse private identifier (#name)
+    * @returns PrivateIdentifier node
+    */
+    parsePrivateIdent(): AST.PrivateIdentifier;
+    /**
+    * Check if identifier is unreserved
+    * @param ref Node with name, start, end
+    */
+    checkUnreserved(ref: {
+      name: string;
+      start: number;
+      end: number;
+    }): void;
+    /**
+    * Parse object expression or pattern
+    * @param isPattern Whether parsing a pattern
+    * @param refDestructuringErrors Error collector
+    * @returns ObjectExpression or ObjectPattern
+    */
+    parseObj(isPattern?: boolean, refDestructuringErrors?: DestructuringErrors): AST.ObjectExpression | AST.ObjectPattern;
+    /**
+    * Parse property in object literal
+    * @param isPattern Whether parsing a pattern
+    * @param refDestructuringErrors Error collector
+    * @returns Property node
+    */
+    parseProperty(isPattern: boolean, refDestructuringErrors?: DestructuringErrors): AST.Property | AST.SpreadElement;
+    /**
+    * Parse property name (identifier, string, number, computed)
+    * @param prop Property node to update
+    * @returns The key expression
+    */
+    parsePropertyName(prop: AST.Node): AST.Expression | AST.PrivateIdentifier;
+    /**
+    * Parse property value
+    * @param prop Property node
+    * @param isPattern Whether parsing pattern
+    * @param isGenerator Whether generator method
+    * @param isAsync Whether async method
+    * @param startPos Start position
+    * @param startLoc Start location
+    * @param refDestructuringErrors Error collector
+    * @param containsEsc Whether key contains escapes
+    */
+    parsePropertyValue(prop: AST.Node, isPattern: boolean, isGenerator: boolean, isAsync: boolean, startPos: number, startLoc: AST.Position, refDestructuringErrors?: DestructuringErrors, containsEsc?: boolean): void;
+    /**
+    * Get property kind from name
+    * @param prop Property node
+    * @returns "init", "get", or "set"
+    */
+    getPropertyKind(prop: AST.Node): "init" | "get" | "set";
+    /**
+    * Parse expression list (array elements, call arguments)
+    * @param close Closing token type
+    * @param allowTrailingComma Whether trailing comma allowed
+    * @param allowEmpty Whether empty slots allowed
+    * @param refDestructuringErrors Error collector
+    * @returns Array of expressions
+    */
+    parseExprList(close: TokenType, allowTrailingComma?: boolean, allowEmpty?: boolean, refDestructuringErrors?: DestructuringErrors): (AST.Expression | null)[];
+    /**
+    * Parse binding list (pattern elements)
+    * @param close Closing token type
+    * @param allowEmpty Whether empty slots allowed
+    * @param allowTrailingComma Whether trailing comma allowed
+    * @param allowModifiers Whether modifiers allowed (TS)
+    */
+    parseBindingList(close: TokenType, allowEmpty?: boolean, allowTrailingComma?: boolean, allowModifiers?: boolean): AST.Pattern[];
+    /**
+    * Parse binding atom (identifier or pattern)
+    * @returns Pattern node
+    */
+    parseBindingAtom(): AST.Pattern;
+    /**
+    * Parse top level program
+    * @param node Program node to populate
+    * @returns Completed Program node
+    */
+    parseTopLevel(node: AST.Program): AST.Program;
+    parseTemplateBody(body: (AST.Statement | AST.Node)[]): void;
+    /**
+    * Parse a statement
+    * @param context Statement context ("for", "if", "label", etc.)
+    * @param topLevel Whether at top level
+    * @param exports Export set for module
+    * @returns Statement node
+    */
+    parseStatement(context?: string | null, topLevel?: boolean, exports?: AST.ExportSpecifier): AST.ExpressionStatement | AST.Statement | AST.GTSDefineStatement;
+    parseBlock(createNewLexicalScope?: boolean, node?: AST.BlockStatement, exitStrict?: boolean): AST.BlockStatement;
+    /** Parse empty statement (;) */
+    parseEmptyStatement(node: AST.Node): AST.EmptyStatement;
+    /** Parse expression statement */
+    parseExpressionStatement(node: AST.Node, expr: AST.Expression): AST.ExpressionStatement;
+    /** Parse labeled statement */
+    parseLabeledStatement(node: AST.Node, maybeName: string, expr: AST.Expression, context?: string): AST.LabeledStatement;
+    /** Parse if statement */
+    parseIfStatement(node: AST.Node): AST.IfStatement;
+    /** Parse switch statement */
+    parseSwitchStatement(node: AST.Node): AST.SwitchStatement;
+    /** Parse while statement */
+    parseWhileStatement(node: AST.Node): AST.WhileStatement;
+    /** Parse do-while statement */
+    parseDoStatement(node: AST.Node): AST.DoWhileStatement;
+    /** Parse for statement (all variants) */
+    parseForStatement(node: AST.ForStatement | AST.ForInStatement | AST.ForOfStatement): AST.ForStatement | AST.ForInStatement | AST.ForOfStatement;
+    parseForAfterInitWithIndex(node: AST.ForStatement | AST.ForInStatement | AST.ForOfStatement, init: AST.VariableDeclaration, awaitAt: number): AST.ForStatement | AST.ForInStatement | AST.ForOfStatement;
+    parseForInWithIndex(node: AST.ForInStatement | AST.ForOfStatement, init: AST.VariableDeclaration | AST.Pattern): AST.ForInStatement | AST.ForOfStatement;
+    /**
+    * Parse regular for loop
+    * @param node For statement node
+    * @param init Initializer expression
+    */
+    parseFor(node: AST.Node, init: AST.Node | null): AST.ForStatement;
+    /**
+    * Parse for-in loop
+    * @param node For statement node
+    * @param init Left-hand binding
+    */
+    parseForIn(node: AST.Node, init: AST.Node): AST.ForInStatement;
+    /** Parse break statement */
+    parseBreakContinueStatement(node: AST.Node, keyword: string): AST.BreakStatement | AST.ContinueStatement;
+    /** Parse return statement */
+    parseReturnStatement(node: AST.Node): AST.ReturnStatement;
+    /** Parse throw statement */
+    parseThrowStatement(node: AST.Node): AST.ThrowStatement;
+    /** Parse try statement */
+    parseTryStatement(node: AST.TryStatement): AST.TryStatement;
+    /**
+    * Parse catch clause parameter
+    * @returns Pattern node for catch param
+    */
+    parseCatchClauseParam(): AST.Pattern;
+    /** Parse with statement */
+    parseWithStatement(node: AST.Node): AST.WithStatement;
+    /** Parse debugger statement */
+    parseDebuggerStatement(node: AST.Node): AST.DebuggerStatement;
+    /** Parse variable statement (var, let, const) */
+    parseVarStatement(node: AST.Node, kind: string): AST.VariableDeclaration;
+    /**
+    * Parse variable declarations
+    * @param node Declaration node
+    * @param isFor Whether in for-loop initializer
+    * @param kind "var", "let", "const", "using", or "await using"
+    * @returns VariableDeclaration node
+    */
+    parseVar(node: AST.Node, isFor: boolean, kind: string): AST.VariableDeclaration;
+    /**
+    * Parse variable ID (identifier or pattern)
+    * @param decl Declarator node
+    * @param kind Variable kind
+    */
+    parseVarId(decl: AST.Node, kind: string): void;
+    /** Check if current token starts 'let' declaration */
+    isLet(context?: string): boolean;
+    /** Check if current token starts 'using' declaration */
+    isUsing?(isFor?: boolean): boolean;
+    /** Check if current token starts 'await using' declaration */
+    isAwaitUsing?(isFor?: boolean): boolean;
+    /**
+    * Parse function declaration or expression
+    */
+    parseFunction(node: AST.Node, statement: number, allowExpressionBody?: boolean, isAsync?: boolean, forInit?: ForInit): AST.FunctionDeclaration | AST.FunctionExpression;
+    /** Parse function statement */
+    parseFunctionStatement(node: AST.Node, isAsync?: boolean, declarationPosition?: boolean): AST.FunctionDeclaration;
+    /**
+    * Parse function parameters into node.params
+    * @param node Function node to populate
+    */
+    parseFunctionParams(node: AST.Node): void;
+    /**
+    * Parse function body
+    */
+    parseFunctionBody(node: AST.Node, isArrowFunction: boolean, isMethod: boolean, forInit?: ForInit): void;
+    /** Initialize function node properties */
+    initFunction(node: AST.Node): void;
+    /** Check for yield/await in default parameters */
+    checkYieldAwaitInDefaultParams(): void;
+    /** Check if async function */
+    isAsyncFunction(): boolean;
+    /**
+    * Parse class declaration or expression
+    * @param node Class node
+    * @param isStatement true, "nullableID", or false
+    */
+    parseClass(node: AST.Node, isStatement: boolean | "nullableID"): AST.ClassDeclaration | AST.ClassExpression;
+    /** Parse class ID (name) */
+    parseClassId(node: AST.Node, isStatement: boolean | "nullableID"): void;
+    /** Parse class superclass */
+    parseClassSuper(node: AST.Node): void;
+    /** Enter class body scope */
+    enterClassBody(): Record<string, any>;
+    /** Exit class body scope */
+    exitClassBody(): void;
+    /**
+    * Parse class element (method, field, static block)
+    * @param constructorAllowsSuper Whether constructor can call super
+    */
+    parseClassElement(constructorAllowsSuper: boolean): AST.MethodDefinition | AST.PropertyDefinition | AST.StaticBlock | null;
+    /** Parse class element name */
+    parseClassElementName(element: AST.Node): void;
+    /** Parse class static block */
+    parseClassStaticBlock(node: AST.Node): AST.StaticBlock;
+    /** Parse class method */
+    parseClassMethod(method: AST.Node, isGenerator: boolean, isAsync: boolean, allowDirectSuper: boolean): AST.MethodDefinition;
+    /** Parse class field */
+    parseClassField(field: AST.Node): AST.PropertyDefinition;
+    /** Check if class element name start */
+    isClassElementNameStart(): boolean;
+    /**
+    * Parse method definition
+    * @param isGenerator Whether generator method
+    * @param isAsync Whether async method
+    * @param allowDirectSuper Whether super() allowed
+    */
+    parseMethod(isGenerator: boolean, isAsync?: boolean, allowDirectSuper?: boolean): AST.FunctionExpression;
+    /** Parse import declaration */
+    parseImport(node: AST.Node): AST.ImportDeclaration;
+    /** Parse import specifiers */
+    parseImportSpecifiers(): AST.ImportSpecifier[];
+    /** Parse single import specifier */
+    parseImportSpecifier(): AST.ImportSpecifier;
+    /** Parse module export name (identifier or string) */
+    parseModuleExportName(): AST.Identifier | AST.Literal;
+    /** Parse export declaration */
+    parseExport(node: AST.Node, exports?: any): AST.ExportNamedDeclaration | AST.ExportDefaultDeclaration | AST.ExportAllDeclaration;
+    /** Parse export specifiers */
+    parseExportSpecifiers(exports?: any): AST.ExportSpecifier[];
+    /** Parse export default declaration */
+    parseExportDefaultDeclaration(): AST.Declaration | AST.Expression;
+    /** Check if export statement should be parsed */
+    shouldParseExportStatement(): boolean;
+    /** Parse export declaration body */
+    parseExportDeclaration(node: AST.Node): AST.Declaration;
+    /**
+    * Convert expression to assignable pattern
+    * @param node Expression to convert
+    * @param isBinding Whether binding pattern
+    * @param refDestructuringErrors Error collector
+    */
+    toAssignable(node: AST.Node, isBinding?: boolean, refDestructuringErrors?: DestructuringErrors): AST.Pattern;
+    /**
+    * Convert expression list to assignable list
+    * @param exprList Expression list
+    * @param isBinding Whether binding patterns
+    */
+    toAssignableList(exprList: AST.Node[], isBinding: boolean): AST.Pattern[];
+    /**
+    * Parse maybe-default pattern (pattern = defaultValue)
+    * @param startPos Start position
+    * @param startLoc Start location
+    * @param left Left-hand pattern
+    */
+    parseMaybeDefault(startPos: number, startLoc: AST.Position, left?: AST.Node): AST.Pattern;
+    /**
+    * Check left-value pattern (for destructuring)
+    */
+    checkLValPattern(node: AST.Node, bindingType?: BindingType[keyof BindingType], checkClashes?: Record<string, boolean>): void;
+    /**
+    * Check left-value simple (identifier or member expression)
+    */
+    checkLValSimple(expr: AST.Node, bindingType?: BindingType[keyof BindingType], checkClashes?: Record<string, boolean>): void;
+    /**
+    * Check left-value inner pattern
+    * @param node Pattern node
+    * @param bindingType Binding type constant
+    * @param checkClashes Clash detection object
+    */
+    checkLValInnerPattern(node: AST.Node, bindingType?: BindingType[keyof BindingType], checkClashes?: Record<string, boolean>): void;
+    /**
+    * Check expression errors
+    * @param refDestructuringErrors Error collector
+    * @param andThrow Whether to throw on error
+    * @returns Whether there were errors
+    */
+    checkExpressionErrors(refDestructuringErrors: DestructuringErrors | null, andThrow?: boolean): boolean;
+    /**
+    * Check if expression is simple assign target
+    * @param expr Expression to check
+    */
+    isSimpleAssignTarget(expr: AST.Node): boolean;
+    /**
+    * Try to parse, returning result with error info if failed
+    * @param fn Parsing function to try
+    * @returns Result with node, error, thrown, aborted, failState
+    */
+    tryParse<T>(fn: () => T): {
+      node: T | null;
+      error: Error | null;
+      thrown: boolean;
+      aborted: boolean;
+      failState: any;
+    };
+    getElementName(node?: AST.Node): string | null;
+    /**
+    * The constructor/class type for the extended Ripple parser.
+    * This represents the static side of the parser class after extending with plugins.
+    */
+    /** Built-in token types */
+    static tokTypes: TokTypes;
+    /** Built-in token contexts */
+    static tokContexts: TokContexts;
+    /** TypeScript extensions when using acorn-typescript */
+    static acornTypeScript: AcornTypeScriptExtensions;
+  }
+}
+//#endregion
 //#region src/config.d.ts
 interface GtsConfig extends TranspileOption {}
 type ReadFileFn = (path: string, encoding: "utf8") => string;
@@ -636,4 +1517,4 @@ declare function resolveGtsConfigSync(filePath: string, inlineConfig: GtsConfig,
 declare function transpile(source: string, filename: string, option: TranspileOption): TranspileResult;
 declare function transpileForVolar(source: string, filename: string, option: TranspileOption): VolarMappingResult;
 //#endregion
-export { type GtsConfig, type ParseLooseOptions as GtsParseLooseOptions, type ParseOptions as GtsParseOptions, GtsTranspilerError, type PathModule, type ResolveGtsConfigAsyncOptions, type ResolveGtsConfigSyncOptions, type TranspileOption, type TranspileResult, type VolarMappingResult, parse, parseLoose, resolveGtsConfig, resolveGtsConfigSync, transpile, transpileForVolar };
+export { type AST, type GtsConfig, type ParseLooseOptions as GtsParseLooseOptions, type ParseOptions as GtsParseOptions, GtsTranspilerError, type PathModule, type ResolveGtsConfigAsyncOptions, type ResolveGtsConfigSyncOptions, type TranspileOption, type TranspileResult, type VolarMappingResult, parse, parseLoose, resolveGtsConfig, resolveGtsConfigSync, transpile, transpileForVolar };