You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
866 lines
21 KiB
866 lines
21 KiB
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<Statement | ModuleDeclaration>
|
|
sourceType: "script" | "module"
|
|
}
|
|
|
|
export interface Function extends Node {
|
|
id?: Identifier | null
|
|
params: Array<Pattern>
|
|
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<Statement>
|
|
}
|
|
|
|
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<SwitchCase>
|
|
}
|
|
|
|
export interface SwitchCase extends Node {
|
|
type: "SwitchCase"
|
|
test?: Expression | null
|
|
consequent: Array<Statement>
|
|
}
|
|
|
|
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<VariableDeclarator>
|
|
kind: "var" | "let" | "const"
|
|
}
|
|
|
|
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<Expression | SpreadElement | null>
|
|
}
|
|
|
|
export interface ObjectExpression extends Node {
|
|
type: "ObjectExpression"
|
|
properties: Array<Property | SpreadElement>
|
|
}
|
|
|
|
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<Expression | SpreadElement>
|
|
optional: boolean
|
|
}
|
|
|
|
export interface NewExpression extends Node {
|
|
type: "NewExpression"
|
|
callee: Expression
|
|
arguments: Array<Expression | SpreadElement>
|
|
}
|
|
|
|
export interface SequenceExpression extends Node {
|
|
type: "SequenceExpression"
|
|
expressions: Array<Expression>
|
|
}
|
|
|
|
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<TemplateElement>
|
|
expressions: Array<Expression>
|
|
}
|
|
|
|
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<AssignmentProperty | RestElement>
|
|
}
|
|
|
|
export interface ArrayPattern extends Node {
|
|
type: "ArrayPattern"
|
|
elements: Array<Pattern | null>
|
|
}
|
|
|
|
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<MethodDefinition | PropertyDefinition | StaticBlock>
|
|
}
|
|
|
|
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<ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier>
|
|
source: Literal
|
|
attributes: Array<ImportAttribute>
|
|
}
|
|
|
|
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<ExportSpecifier>
|
|
source?: Literal | null
|
|
attributes: Array<ImportAttribute>
|
|
}
|
|
|
|
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<ImportAttribute>
|
|
}
|
|
|
|
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<Statement>
|
|
}
|
|
|
|
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
|
|
|
|
export type AnyNode = 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 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<Token>
|
|
}
|
|
|
|
export type ecmaVersion = 3 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 2015 | 2016 | 2017 | 2018 | 2019 | 2020 | 2021 | 2022 | 2023 | 2024 | 2025 | "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<Token>
|
|
}
|
|
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
|