export interface Node { start: number end: number type: string range?: [number, number] loc?: SourceLocation | null } export interface SourceLocation { source?: string | null start: Position end: Position } export interface Position { /** 1-based */ line: number /** 0-based */ column: number } export interface Identifier extends Node { type: "Identifier" name: string } export interface Literal extends Node { type: "Literal" value?: string | boolean | null | number | RegExp | bigint raw?: string regex?: { pattern: string flags: string } bigint?: string } export interface Program extends Node { type: "Program" body: Array sourceType: "script" | "module" } export interface Function extends Node { id?: Identifier | null params: Array body: BlockStatement | Expression generator: boolean expression: boolean async: boolean } export interface ExpressionStatement extends Node { type: "ExpressionStatement" expression: Expression | Literal directive?: string } export interface BlockStatement extends Node { type: "BlockStatement" body: Array } export interface EmptyStatement extends Node { type: "EmptyStatement" } export interface DebuggerStatement extends Node { type: "DebuggerStatement" } export interface WithStatement extends Node { type: "WithStatement" object: Expression body: Statement } export interface ReturnStatement extends Node { type: "ReturnStatement" argument?: Expression | null } export interface LabeledStatement extends Node { type: "LabeledStatement" label: Identifier body: Statement } export interface BreakStatement extends Node { type: "BreakStatement" label?: Identifier | null } export interface ContinueStatement extends Node { type: "ContinueStatement" label?: Identifier | null } export interface IfStatement extends Node { type: "IfStatement" test: Expression consequent: Statement alternate?: Statement | null } export interface SwitchStatement extends Node { type: "SwitchStatement" discriminant: Expression cases: Array } export interface SwitchCase extends Node { type: "SwitchCase" test?: Expression | null consequent: Array } export interface ThrowStatement extends Node { type: "ThrowStatement" argument: Expression } export interface TryStatement extends Node { type: "TryStatement" block: BlockStatement handler?: CatchClause | null finalizer?: BlockStatement | null } export interface CatchClause extends Node { type: "CatchClause" param?: Pattern | null body: BlockStatement } export interface WhileStatement extends Node { type: "WhileStatement" test: Expression body: Statement } export interface DoWhileStatement extends Node { type: "DoWhileStatement" body: Statement test: Expression } export interface ForStatement extends Node { type: "ForStatement" init?: VariableDeclaration | Expression | null test?: Expression | null update?: Expression | null body: Statement } export interface ForInStatement extends Node { type: "ForInStatement" left: VariableDeclaration | Pattern right: Expression body: Statement } export interface FunctionDeclaration extends Function { type: "FunctionDeclaration" id: Identifier body: BlockStatement } export interface VariableDeclaration extends Node { type: "VariableDeclaration" declarations: Array kind: "var" | "let" | "const" | "using" | "await using" } export interface VariableDeclarator extends Node { type: "VariableDeclarator" id: Pattern init?: Expression | null } export interface ThisExpression extends Node { type: "ThisExpression" } export interface ArrayExpression extends Node { type: "ArrayExpression" elements: Array } export interface ObjectExpression extends Node { type: "ObjectExpression" properties: Array } export interface Property extends Node { type: "Property" key: Expression value: Expression kind: "init" | "get" | "set" method: boolean shorthand: boolean computed: boolean } export interface FunctionExpression extends Function { type: "FunctionExpression" body: BlockStatement } export interface UnaryExpression extends Node { type: "UnaryExpression" operator: UnaryOperator prefix: boolean argument: Expression } export type UnaryOperator = "-" | "+" | "!" | "~" | "typeof" | "void" | "delete" export interface UpdateExpression extends Node { type: "UpdateExpression" operator: UpdateOperator argument: Expression prefix: boolean } export type UpdateOperator = "++" | "--" export interface BinaryExpression extends Node { type: "BinaryExpression" operator: BinaryOperator left: Expression | PrivateIdentifier right: Expression } export type BinaryOperator = "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "<<" | ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "|" | "^" | "&" | "in" | "instanceof" | "**" export interface AssignmentExpression extends Node { type: "AssignmentExpression" operator: AssignmentOperator left: Pattern right: Expression } export type AssignmentOperator = "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=" | "**=" | "||=" | "&&=" | "??=" export interface LogicalExpression extends Node { type: "LogicalExpression" operator: LogicalOperator left: Expression right: Expression } export type LogicalOperator = "||" | "&&" | "??" export interface MemberExpression extends Node { type: "MemberExpression" object: Expression | Super property: Expression | PrivateIdentifier computed: boolean optional: boolean } export interface ConditionalExpression extends Node { type: "ConditionalExpression" test: Expression alternate: Expression consequent: Expression } export interface CallExpression extends Node { type: "CallExpression" callee: Expression | Super arguments: Array optional: boolean } export interface NewExpression extends Node { type: "NewExpression" callee: Expression arguments: Array } export interface SequenceExpression extends Node { type: "SequenceExpression" expressions: Array } export interface ForOfStatement extends Node { type: "ForOfStatement" left: VariableDeclaration | Pattern right: Expression body: Statement await: boolean } export interface Super extends Node { type: "Super" } export interface SpreadElement extends Node { type: "SpreadElement" argument: Expression } export interface ArrowFunctionExpression extends Function { type: "ArrowFunctionExpression" } export interface YieldExpression extends Node { type: "YieldExpression" argument?: Expression | null delegate: boolean } export interface TemplateLiteral extends Node { type: "TemplateLiteral" quasis: Array expressions: Array } export interface TaggedTemplateExpression extends Node { type: "TaggedTemplateExpression" tag: Expression quasi: TemplateLiteral } export interface TemplateElement extends Node { type: "TemplateElement" tail: boolean value: { cooked?: string | null raw: string } } export interface AssignmentProperty extends Node { type: "Property" key: Expression value: Pattern kind: "init" method: false shorthand: boolean computed: boolean } export interface ObjectPattern extends Node { type: "ObjectPattern" properties: Array } export interface ArrayPattern extends Node { type: "ArrayPattern" elements: Array } export interface RestElement extends Node { type: "RestElement" argument: Pattern } export interface AssignmentPattern extends Node { type: "AssignmentPattern" left: Pattern right: Expression } export interface Class extends Node { id?: Identifier | null superClass?: Expression | null body: ClassBody } export interface ClassBody extends Node { type: "ClassBody" body: Array } export interface MethodDefinition extends Node { type: "MethodDefinition" key: Expression | PrivateIdentifier value: FunctionExpression kind: "constructor" | "method" | "get" | "set" computed: boolean static: boolean } export interface ClassDeclaration extends Class { type: "ClassDeclaration" id: Identifier } export interface ClassExpression extends Class { type: "ClassExpression" } export interface MetaProperty extends Node { type: "MetaProperty" meta: Identifier property: Identifier } export interface ImportDeclaration extends Node { type: "ImportDeclaration" specifiers: Array source: Literal attributes: Array } export interface ImportSpecifier extends Node { type: "ImportSpecifier" imported: Identifier | Literal local: Identifier } export interface ImportDefaultSpecifier extends Node { type: "ImportDefaultSpecifier" local: Identifier } export interface ImportNamespaceSpecifier extends Node { type: "ImportNamespaceSpecifier" local: Identifier } export interface ImportAttribute extends Node { type: "ImportAttribute" key: Identifier | Literal value: Literal } export interface ExportNamedDeclaration extends Node { type: "ExportNamedDeclaration" declaration?: Declaration | null specifiers: Array source?: Literal | null attributes: Array } export interface ExportSpecifier extends Node { type: "ExportSpecifier" exported: Identifier | Literal local: Identifier | Literal } export interface AnonymousFunctionDeclaration extends Function { type: "FunctionDeclaration" id: null body: BlockStatement } export interface AnonymousClassDeclaration extends Class { type: "ClassDeclaration" id: null } export interface ExportDefaultDeclaration extends Node { type: "ExportDefaultDeclaration" declaration: AnonymousFunctionDeclaration | FunctionDeclaration | AnonymousClassDeclaration | ClassDeclaration | Expression } export interface ExportAllDeclaration extends Node { type: "ExportAllDeclaration" source: Literal exported?: Identifier | Literal | null attributes: Array } export interface AwaitExpression extends Node { type: "AwaitExpression" argument: Expression } export interface ChainExpression extends Node { type: "ChainExpression" expression: MemberExpression | CallExpression } export interface ImportExpression extends Node { type: "ImportExpression" source: Expression options: Expression | null } export interface ParenthesizedExpression extends Node { type: "ParenthesizedExpression" expression: Expression } export interface PropertyDefinition extends Node { type: "PropertyDefinition" key: Expression | PrivateIdentifier value?: Expression | null computed: boolean static: boolean } export interface PrivateIdentifier extends Node { type: "PrivateIdentifier" name: string } export interface StaticBlock extends Node { type: "StaticBlock" body: Array } export type Statement = | ExpressionStatement | BlockStatement | EmptyStatement | DebuggerStatement | WithStatement | ReturnStatement | LabeledStatement | BreakStatement | ContinueStatement | IfStatement | SwitchStatement | ThrowStatement | TryStatement | WhileStatement | DoWhileStatement | ForStatement | ForInStatement | ForOfStatement | Declaration export type Declaration = | FunctionDeclaration | VariableDeclaration | ClassDeclaration export type Expression = | Identifier | Literal | ThisExpression | ArrayExpression | ObjectExpression | FunctionExpression | UnaryExpression | UpdateExpression | BinaryExpression | AssignmentExpression | LogicalExpression | MemberExpression | ConditionalExpression | CallExpression | NewExpression | SequenceExpression | ArrowFunctionExpression | YieldExpression | TemplateLiteral | TaggedTemplateExpression | ClassExpression | MetaProperty | AwaitExpression | ChainExpression | ImportExpression | ParenthesizedExpression export type Pattern = | Identifier | MemberExpression | ObjectPattern | ArrayPattern | RestElement | AssignmentPattern export type ModuleDeclaration = | ImportDeclaration | ExportNamedDeclaration | ExportDefaultDeclaration | ExportAllDeclaration /** * This interface is only used for defining {@link AnyNode}. * It exists so that it can be extended by plugins: * * @example * ```typescript * declare module 'acorn' { * interface NodeTypes { * pluginName: FirstNode | SecondNode | ThirdNode | ... | LastNode * } * } * ``` */ interface NodeTypes { core: Statement | Expression | Declaration | ModuleDeclaration | Literal | Program | SwitchCase | CatchClause | Property | Super | SpreadElement | TemplateElement | AssignmentProperty | ObjectPattern | ArrayPattern | RestElement | AssignmentPattern | ClassBody | MethodDefinition | MetaProperty | ImportAttribute | ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ExportSpecifier | AnonymousFunctionDeclaration | AnonymousClassDeclaration | PropertyDefinition | PrivateIdentifier | StaticBlock | VariableDeclarator } export type AnyNode = NodeTypes[keyof NodeTypes] export function parse(input: string, options: Options): Program export function parseExpressionAt(input: string, pos: number, options: Options): Expression export function tokenizer(input: string, options: Options): { getToken(): Token [Symbol.iterator](): Iterator } export type ecmaVersion = 3 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 2015 | 2016 | 2017 | 2018 | 2019 | 2020 | 2021 | 2022 | 2023 | 2024 | 2025 | 2026 | "latest" export interface Options { /** * `ecmaVersion` indicates the ECMAScript version to parse. Can be a * number, either in year (`2022`) or plain version number (`6`) form, * or `"latest"` (the latest the library supports). This influences * support for strict mode, the set of reserved words, and support for * new syntax features. */ ecmaVersion: ecmaVersion /** * `sourceType` indicates the mode the code should be parsed in. * Can be either `"script"` or `"module"`. This influences global * strict mode and parsing of `import` and `export` declarations. */ sourceType?: "script" | "module" /** * a callback that will be called when a semicolon is automatically inserted. * @param lastTokEnd the position of the comma as an offset * @param lastTokEndLoc location if {@link locations} is enabled */ onInsertedSemicolon?: (lastTokEnd: number, lastTokEndLoc?: Position) => void /** * similar to `onInsertedSemicolon`, but for trailing commas * @param lastTokEnd the position of the comma as an offset * @param lastTokEndLoc location if `locations` is enabled */ onTrailingComma?: (lastTokEnd: number, lastTokEndLoc?: Position) => void /** * By default, reserved words are only enforced if ecmaVersion >= 5. * Set `allowReserved` to a boolean value to explicitly turn this on * an off. When this option has the value "never", reserved words * and keywords can also not be used as property names. */ allowReserved?: boolean | "never" /** * When enabled, a return at the top level is not considered an error. */ allowReturnOutsideFunction?: boolean /** * When enabled, import/export statements are not constrained to * appearing at the top of the program, and an import.meta expression * in a script isn't considered an error. */ allowImportExportEverywhere?: boolean /** * By default, `await` identifiers are allowed to appear at the top-level scope only if {@link ecmaVersion} >= 2022. * When enabled, await identifiers are allowed to appear at the top-level scope, * but they are still not allowed in non-async functions. */ allowAwaitOutsideFunction?: boolean /** * When enabled, super identifiers are not constrained to * appearing in methods and do not raise an error when they appear elsewhere. */ allowSuperOutsideMethod?: boolean /** * When enabled, hashbang directive in the beginning of file is * allowed and treated as a line comment. Enabled by default when * {@link ecmaVersion} >= 2023. */ allowHashBang?: boolean /** * By default, the parser will verify that private properties are * only used in places where they are valid and have been declared. * Set this to false to turn such checks off. */ checkPrivateFields?: boolean /** * When `locations` is on, `loc` properties holding objects with * `start` and `end` properties as {@link Position} objects will be attached to the * nodes. */ locations?: boolean /** * a callback that will cause Acorn to call that export function with object in the same * format as tokens returned from `tokenizer().getToken()`. Note * that you are not allowed to call the parser from the * callback—that will corrupt its internal state. */ onToken?: ((token: Token) => void) | Token[] /** * This takes a export function or an array. * * When a export function is passed, Acorn will call that export function with `(block, text, start, * end)` parameters whenever a comment is skipped. `block` is a * boolean indicating whether this is a block (`/* *\/`) comment, * `text` is the content of the comment, and `start` and `end` are * character offsets that denote the start and end of the comment. * When the {@link locations} option is on, two more parameters are * passed, the full locations of {@link Position} export type of the start and * end of the comments. * * When a array is passed, each found comment of {@link Comment} export type is pushed to the array. * * Note that you are not allowed to call the * parser from the callback—that will corrupt its internal state. */ onComment?: (( isBlock: boolean, text: string, start: number, end: number, startLoc?: Position, endLoc?: Position ) => void) | Comment[] /** * Nodes have their start and end characters offsets recorded in * `start` and `end` properties (directly on the node, rather than * the `loc` object, which holds line/column data. To also add a * [semi-standardized][range] `range` property holding a `[start, * end]` array with the same numbers, set the `ranges` option to * `true`. */ ranges?: boolean /** * It is possible to parse multiple files into a single AST by * passing the tree produced by parsing the first file as * `program` option in subsequent parses. This will add the * toplevel forms of the parsed file to the `Program` (top) node * of an existing parse tree. */ program?: Node /** * When {@link locations} is on, you can pass this to record the source * file in every node's `loc` object. */ sourceFile?: string /** * This value, if given, is stored in every node, whether {@link locations} is on or off. */ directSourceFile?: string /** * When enabled, parenthesized expressions are represented by * (non-standard) ParenthesizedExpression nodes */ preserveParens?: boolean } export class Parser { options: Options input: string protected constructor(options: Options, input: string, startPos?: number) parse(): Program static parse(input: string, options: Options): Program static parseExpressionAt(input: string, pos: number, options: Options): Expression static tokenizer(input: string, options: Options): { getToken(): Token [Symbol.iterator](): Iterator } static extend(...plugins: ((BaseParser: typeof Parser) => typeof Parser)[]): typeof Parser } export const defaultOptions: Options export function getLineInfo(input: string, offset: number): Position export class TokenType { label: string keyword: string | undefined } export const tokTypes: { num: TokenType regexp: TokenType string: TokenType name: TokenType privateId: TokenType eof: TokenType bracketL: TokenType bracketR: TokenType braceL: TokenType braceR: TokenType parenL: TokenType parenR: TokenType comma: TokenType semi: TokenType colon: TokenType dot: TokenType question: TokenType questionDot: TokenType arrow: TokenType template: TokenType invalidTemplate: TokenType ellipsis: TokenType backQuote: TokenType dollarBraceL: TokenType eq: TokenType assign: TokenType incDec: TokenType prefix: TokenType logicalOR: TokenType logicalAND: TokenType bitwiseOR: TokenType bitwiseXOR: TokenType bitwiseAND: TokenType equality: TokenType relational: TokenType bitShift: TokenType plusMin: TokenType modulo: TokenType star: TokenType slash: TokenType starstar: TokenType coalesce: TokenType _break: TokenType _case: TokenType _catch: TokenType _continue: TokenType _debugger: TokenType _default: TokenType _do: TokenType _else: TokenType _finally: TokenType _for: TokenType _function: TokenType _if: TokenType _return: TokenType _switch: TokenType _throw: TokenType _try: TokenType _var: TokenType _const: TokenType _while: TokenType _with: TokenType _new: TokenType _this: TokenType _super: TokenType _class: TokenType _extends: TokenType _export: TokenType _import: TokenType _null: TokenType _true: TokenType _false: TokenType _in: TokenType _instanceof: TokenType _typeof: TokenType _void: TokenType _delete: TokenType } export interface Comment { type: "Line" | "Block" value: string start: number end: number loc?: SourceLocation range?: [number, number] } export class Token { type: TokenType start: number end: number loc?: SourceLocation range?: [number, number] } export const version: string