Esprima syntax tree format is derived from the original version of Mozilla Parser API, which is then formalized and expanded as the ESTree specification.
Note: In the following sections, interfaces are described using the syntax of TypeScript interface.
Each node is represented as a regular JavaScript object that implements the interface:
interface Node { type: string; }
The type
property is a string that contains the variant type of the node. Each subtype of Node is explained in the subsequent sections.
When the node is annotated with its location, the interface becomes:
interface Node { type: string; range?: [number, number]; loc?: SourceLocation; }
with the source location defined as:
interface Position { line: number; column: number; } interface SourceLocation { start: Position; end: Position; source?: string | null; }
A binding pattern can be one of the following:
type BindingPattern = ArrayPattern | ObjectPattern;
An expression can be one of the following:
type Expression = ThisExpression | Identifier | Literal | ArrayExpression | ObjectExpression | FunctionExpression | ArrowFunctionExpression | ClassExpression | TaggedTemplateExpression | MemberExpression | Super | MetaProperty | NewExpression | CallExpression | UpdateExpression | AwaitExpression | UnaryExpression | BinaryExpression | LogicalExpression | ConditionalExpression | YieldExpression | AssignmentExpression | SequenceExpression;
interface ArrayPattern { type: 'ArrayPattern'; elements: ArrayPatternElement[]; }
with
type ArrayPatternElement = AssignmentPattern | Identifier | BindingPattern | RestElement | null; interface RestElement { type: 'RestElement'; argument: Identifier | BindingPattern; }
interface AssignmentPattern { type: 'AssignmentPattern'; left: Identifier | BindingPattern; right: Expression; }
interface ObjectPattern { type: 'ObjectPattern'; properties: Property[]; }
interface ThisExpression { type: 'ThisExpression'; }
interface Identifier { type: 'Identifier'; name: string; }
interface Literal { type: 'Literal'; value: boolean | number | string | RegExp | null; raw: string; regex?: { pattern: string, flags: string }; }
The regex
property only applies to regular expression literals.
interface ArrayExpression { type: 'ArrayExpression'; elements: ArrayExpressionElement[]; }
where
type ArrayExpressionElement = Expression | SpreadElement;
interface ObjectExpression { type: 'ObjectExpression'; properties: Property[]; }
where
interface Property { type: 'Property'; key: Expression; computed: boolean; value: Expression | null; kind: 'get' | 'set' | 'init'; method: false; shorthand: boolean; }
interface FunctionExpression { type: 'FunctionExpression'; id: Identifier | null; params: FunctionParameter[]; body: BlockStatement; generator: boolean; async: boolean; expression: boolean; }
with
type FunctionParameter = AssignmentPattern | Identifier | BindingPattern;
The value of generator
is true for a generator expression.
interface ArrowFunctionExpression { type: 'ArrowFunctionExpression'; id: Identifier | null; params: FunctionParameter[]; body: BlockStatement | Expression; generator: boolean; async: boolean; expression: false; }
interface ClassExpression { type: 'ClassExpression'; id: Identifier | null; superClass: Identifier | null; body: ClassBody; }
with
interface ClassBody { type: 'ClassBody'; body: MethodDefinition[]; } interface MethodDefinition { type: 'MethodDefinition'; key: Expression | null; computed: boolean; value: FunctionExpression | null; kind: 'method' | 'constructor'; static: boolean; }
interface TaggedTemplateExpression { type: 'TaggedTemplateExpression'; readonly tag: Expression; readonly quasi: TemplateLiteral; }
with
interface TemplateElement { type: 'TemplateElement'; value: { cooked: string; raw: string }; tail: boolean; } interface TemplateLiteral { type: 'TemplateLiteral'; quasis: TemplateElement[]; expressions: Expression[]; }
interface MemberExpression { type: 'MemberExpression'; computed: boolean; object: Expression; property: Expression; }
interface Super { type: 'Super'; }
interface MetaProperty { type: 'MetaProperty'; meta: Identifier; property: Identifier; }
interface CallExpression { type: 'CallExpression'; callee: Expression | Import; arguments: ArgumentListElement[]; } interface NewExpression { type: 'NewExpression'; callee: Expression; arguments: ArgumentListElement[]; }
with
interface Import { type: 'Import'; } type ArgumentListElement = Expression | SpreadElement; interface SpreadElement { type: 'SpreadElement'; argument: Expression; }
interface UpdateExpression { type: 'UpdateExpression'; operator: '++' | '--'; argument: Expression; prefix: boolean; }
interface AwaitExpression { type: 'AwaitExpression'; argument: Expression; }
interface UnaryExpression { type: 'UnaryExpression'; operator: '+' | '-' | '~' | '!' | 'delete' | 'void' | 'typeof'; argument: Expression; prefix: true; }
interface BinaryExpression { type: 'BinaryExpression'; operator: 'instanceof' | 'in' | '+' | '-' | '*' | '/' | '%' | '**' | '|' | '^' | '&' | '==' | '!=' | '===' | '!==' | '<' | '>' | '<=' | '<<' | '>>' | '>>>'; left: Expression; right: Expression; }
interface LogicalExpression { type: 'LogicalExpression'; operator: '||' | '&&'; left: Expression; right: Expression; }
interface ConditionalExpression { type: 'ConditionalExpression'; test: Expression; consequent: Expression; alternate: Expression; }
interface YieldExpression { type: 'YieldExpression'; argument: Expression | null; delegate: boolean; }
interface AssignmentExpression { type: 'AssignmentExpression'; operator: '=' | '*=' | '**=' | '/=' | '%=' | '+=' | '-=' | '<<=' | '>>=' | '>>>=' | '&=' | '^=' | '|='; left: Expression; right: Expression; }
interface SequenceExpression { type: 'SequenceExpression'; expressions: Expression[]; }
A statement can be one of the following:
type Statement = BlockStatement | BreakStatement | ContinueStatement | DebuggerStatement | DoWhileStatement | EmptyStatement | ExpressionStatement | ForStatement | ForInStatement | ForOfStatement | FunctionDeclaration | IfStatement | LabeledStatement | ReturnStatement | SwitchStatement | ThrowStatement | TryStatement | VariableDeclaration | WhileStatement | WithStatement;
A declaration can be one of the following:
type Declaration = ClassDeclaration | FunctionDeclaration | VariableDeclaration;
A statement list item is either a statement or a declaration:
type StatementListItem = Declaration | Statement;
A series of statements enclosed by a pair of curly braces form a block statement:
interface BlockStatement { type: 'BlockStatement'; body: StatementListItem[]; }
interface BreakStatement { type: 'BreakStatement'; label: Identifier | null; }
interface ClassDeclaration { type: 'ClassDeclaration'; id: Identifier | null; superClass: Identifier | null; body: ClassBody; }
interface ContinueStatement { type: 'ContinueStatement'; label: Identifier | null; }
interface DebuggerStatement { type: 'DebuggerStatement'; }
interface DoWhileStatement { type: 'DoWhileStatement'; body: Statement; test: Expression; }
interface EmptyStatement { type: 'EmptyStatement'; }
interface ExpressionStatement { type: 'ExpressionStatement'; expression: Expression; directive?: string; }
When the expression statement represents a directive (such as "use strict"
), then the directive
property will contain the directive string.
interface ForStatement { type: 'ForStatement'; init: Expression | VariableDeclaration | null; test: Expression | null; update: Expression | null; body: Statement; }
interface ForInStatement { type: 'ForInStatement'; left: Expression; right: Expression; body: Statement; each: false; }
interface ForOfStatement { type: 'ForOfStatement'; left: Expression; right: Expression; body: Statement; }
interface FunctionDeclaration { type: 'FunctionDeclaration'; id: Identifier | null; params: FunctionParameter[]; body: BlockStatement; generator: boolean; async: boolean; expression: false; }
with
type FunctionParameter = AssignmentPattern | Identifier | BindingPattern;
interface IfStatement { type: 'IfStatement'; test: Expression; consequent: Statement; alternate?: Statement; }
A statement prefixed by a label becomes a labelled statement:
interface LabeledStatement { type: 'LabeledStatement'; label: Identifier; body: Statement; }
interface ReturnStatement { type: 'ReturnStatement'; argument: Expression | null; }
interface SwitchStatement { type: 'SwitchStatement'; discriminant: Expression; cases: SwitchCase[]; }
with
interface SwitchCase { type: 'SwitchCase'; test: Expression | null; consequent: Statement[]; }
interface ThrowStatement { type: 'ThrowStatement'; argument: Expression; }
interface TryStatement { type: 'TryStatement'; block: BlockStatement; handler: CatchClause | null; finalizer: BlockStatement | null; }
with
interface CatchClause { type: 'CatchClause'; param: Identifier | BindingPattern; body: BlockStatement; }
interface VariableDeclaration { type: 'VariableDeclaration'; declarations: VariableDeclarator[]; kind: 'var' | 'const' | 'let'; }
with
interface VariableDeclarator { type: 'VariableDeclarator'; id: Identifier | BindingPattern; init: Expression | null; }
interface WhileStatement { type: 'WhileStatement'; test: Expression; body: Statement; }
interface WithStatement { type: 'WithStatement'; object: Expression; body: Statement; }
A program can be either a script or a module.
interface Program { type: 'Program'; sourceType: 'script'; body: StatementListItem[]; } interface Program { type: 'Program'; sourceType: 'module'; body: ModuleItem[]; }
with
type StatementListItem = Declaration | Statement; type ModuleItem = ImportDeclaration | ExportDeclaration | StatementListItem;
type ImportDeclaration { type: 'ImportDeclaration'; specifiers: ImportSpecifier[]; source: Literal; }
with
interface ImportSpecifier { type: 'ImportSpecifier' | 'ImportDefaultSpecifier' | 'ImportNamespaceSpecifier'; local: Identifier; imported?: Identifier; }
An export declaration can be in the form of a batch, a default, or a named declaration.
type ExportDeclaration = ExportAllDeclaration | ExportDefaultDeclaration | ExportNamedDeclaration;
Each possible export declaration is described as follows:
interface ExportAllDeclaration { type: 'ExportAllDeclaration'; source: Literal; } interface ExportDefaultDeclaration { type: 'ExportDefaultDeclaration'; declaration: Identifier | BindingPattern | ClassDeclaration | Expression | FunctionDeclaration; } interface ExportNamedDeclaration { type: 'ExportNamedDeclaration'; declaration: ClassDeclaration | FunctionDeclaration | VariableDeclaration; specifiers: ExportSpecifier[]; source: Literal; }
with
interface ExportSpecifier { type: 'ExportSpecifier'; exported: Identifier; local: Identifier; };