Welcome to ESTree explorer

extend interface Program {
    sourceType: "script" | "module";
    body: [ Statement | ModuleDeclaration ];
}

Parsers must specify sourceType as "module" if the source has been parsed as an ES6 module. Otherwise, sourceType must be "script".

interface Program <: Node {
    type: "Program";
    body: [ Directive | Statement ];
}

A complete program source tree.

extend interface Function {
    generator: boolean;
}

interface Function <: Node {
    id: Identifier | null;
    params: [ Pattern ];
    body: FunctionBody;
}

A function declaration or expression.

extend interface Function {
    returnType: TypeAnnotation | null;
}

The returnType property is used to specify the type annotation for the return value of the function.

interface ForOfStatement <: ForInStatement {
    type: "ForOfStatement";
}

extend interface VariableDeclaration {
    kind: "var" | "let" | "const";
}

interface VariableDeclaration <: Declaration {
    type: "VariableDeclaration";
    declarations: [ VariableDeclarator ];
    kind: "var";
}

A variable declaration.

interface Super <: Node {
    type: "Super";
}

extend interface CallExpression {
    callee: Expression | Super;
    arguments: [ Expression | SpreadElement ];
}

extend interface MemberExpression {
    object: Expression | Super;
}

A super pseudo-expression.

interface SpreadElement <: Node {
    type: "SpreadElement";
    argument: Expression;
}

extend interface ArrayExpression {
    elements: [ Expression | SpreadElement | null ];
}

extend interface NewExpression {
    arguments: [ Expression | SpreadElement ];
}

Spread expression, e.g., [head, ...iter, tail], f(head, ...iter, ...tail).

extend interface AssignmentExpression {
    left: Pattern;
}

Note that pre-ES6 code was allowed to pass references around and so left was much more liberal; an implementation might choose to continue using old definition if it needs to support such legacy code.

extend interface Property {
    key: Expression;
    method: boolean;
    shorthand: boolean;
    computed: boolean;
}

extend interface ObjectExpression {
    properties: [ Property | SpreadElement ];
}

Spread properties, e.g., {a: 1, ...obj, b: 2}.

interface Expression <: Node { }

Any expression node. Since the left-hand side of an assignment may be any expression in general, an expression can also be a pattern.

interface ArrowFunctionExpression <: Function, Expression {
    type: "ArrowFunctionExpression";
    body: FunctionBody | Expression;
    expression: boolean;
    generator: false;
}

A fat arrow function expression, e.g., let foo = (bar) => { /* body */ }.

interface YieldExpression <: Expression {
    type: "YieldExpression";
    argument: Expression | null;
    delegate: boolean;
}

A yield expression.

interface TemplateLiteral <: Expression {
    type: "TemplateLiteral";
    quasis: [ TemplateElement ];
    expressions: [ Expression ];
}

interface TaggedTemplateExpression <: Expression {
    type: "TaggedTemplateExpression";
    tag: Expression;
    quasi: TemplateLiteral;
}

interface TemplateElement <: Node {
    type: "TemplateElement";
    tail: boolean;
    value: {
        cooked: string;
        raw: string;
    };
}

interface AssignmentProperty <: Property {
    type: "Property"; // inherited
    value: Pattern;
    kind: "init";
    method: false;
}

interface ObjectPattern <: Pattern {
    type: "ObjectPattern";
    properties: [ AssignmentProperty ];
}

extend interface ObjectPattern {
    typeAnnotation: TypeAnnotation | null;
}

interface ArrayPattern <: Pattern {
    type: "ArrayPattern";
    elements: [ Pattern | null ];
}

extend interface ArrayPattern {
    typeAnnotation: TypeAnnotation | null;
}

interface RestElement <: Pattern {
    type: "RestElement";
    argument: Pattern;
}

extend interface RestElement {
    typeAnnotation: TypeAnnotation | null;
}

interface AssignmentPattern <: Pattern {
    type: "AssignmentPattern";
    left: Pattern;
    right: Expression;
}

interface Class <: Node {
    id: Identifier | null;
    superClass: Expression | null;
    body: ClassBody;
}

These language extensions cover following class features proposals:

• Class Fields
• Static Class Features
• Private Methods
• Static Initialization Blocks.

interface ClassBody <: Node {
    type: "ClassBody";
    body: [ MethodDefinition ];
}

extend interface ClassBody {
    body: [ MethodDefinition | PropertyDefinition | StaticBlock ];
}

interface MethodDefinition <: Node {
    type: "MethodDefinition";
    key: Expression;
    value: FunctionExpression;
    kind: "constructor" | "method" | "get" | "set";
    computed: boolean;
    static: boolean;
}

extend interface MethodDefinition {
    key: Expression | PrivateIdentifier;
}

• When key is a PrivateIdentifier, computed must be false and kind can not be "constructor".

interface ClassDeclaration <: Class, Declaration {
    type: "ClassDeclaration";
    id: Identifier;
}

interface ClassExpression <: Class, Expression {
    type: "ClassExpression";
}

interface MetaProperty <: Expression {
    type: "MetaProperty";
    meta: Identifier;
    property: Identifier;
}

• MetaProperty node represents new.target meta property in ES2015. In the future, it will represent other meta properties as well.

interface ModuleDeclaration <: Node { }

A module import or export declaration.

interface ModuleSpecifier <: Node {
    local: Identifier;
}

A specifier in an import or export declaration.

interface ImportDeclaration <: ModuleDeclaration {
    type: "ImportDeclaration";
    specifiers: [ ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier ];
    source: Literal;
}

An import declaration, e.g., import foo from "mod";.

interface ImportSpecifier <: ModuleSpecifier {
    type: "ImportSpecifier";
    imported: Identifier;
}

An imported variable binding, e.g., {foo} in import {foo} from "mod" or {foo as bar} in import {foo as bar} from "mod". The imported field refers to the name of the export imported from the module. The local field refers to the binding imported into the local module scope. If it is a basic named import, such as in import {foo} from "mod", both imported and local are equivalent Identifier nodes; in this case an Identifier node representing foo. If it is an aliased import, such as in import {foo as bar} from "mod", the imported field is an Identifier node representing foo, and the local field is an Identifier node representing bar.

extend interface ImportSpecifier <: ModuleSpecifier {
    imported: Identifier | Literal;
}

If imported is a Literal, imported.value must be a string without lone surrogate.

interface ImportDefaultSpecifier <: ModuleSpecifier {
    type: "ImportDefaultSpecifier";
}

A default import specifier, e.g., foo in import foo from "mod.js".

interface ImportNamespaceSpecifier <: ModuleSpecifier {
    type: "ImportNamespaceSpecifier";
}

A namespace import specifier, e.g., * as foo in import * as foo from "mod.js".

interface ExportNamedDeclaration <: ModuleDeclaration {
    type: "ExportNamedDeclaration";
    declaration: Declaration | null;
    specifiers: [ ExportSpecifier ];
    source: Literal | null;
}

An export named declaration, e.g., export {foo, bar};, export {foo} from "mod"; or export var foo = 1;.

interface ExportSpecifier <: ModuleSpecifier {
    type: "ExportSpecifier";
    exported: Identifier;
}

An exported variable binding, e.g., {foo} in export {foo} or {bar as foo} in export {bar as foo}. The exported field refers to the name exported in the module. The local field refers to the binding into the local module scope. If it is a basic named export, such as in export {foo}, both exported and local are equivalent Identifier nodes; in this case an Identifier node representing foo. If it is an aliased export, such as in export {bar as foo}, the exported field is an Identifier node representing foo, and the local field is an Identifier node representing bar.

extend interface ExportSpecifier <: ModuleSpecifier {
    local: Identifier | Literal;
    exported: Identifier | Literal;
}

If exported/local is Literal, exported.value/local.value must be a string without lone surrogate.

interface AnonymousDefaultExportedFunctionDeclaration <: Function {
    type: "FunctionDeclaration";
    id: null;
}

interface AnonymousDefaultExportedClassDeclaration <: Class {
    type: "ClassDeclaration";
    id: null;
}

interface ExportDefaultDeclaration <: ModuleDeclaration {
    type: "ExportDefaultDeclaration";
    declaration: AnonymousDefaultExportedFunctionDeclaration | FunctionDeclaration | AnonymousDefaultExportedClassDeclaration | ClassDeclaration | Expression;
}

An export default declaration, e.g., export default function () {}; or export default 1;.

interface ExportAllDeclaration <: ModuleDeclaration {
    type: "ExportAllDeclaration";
    source: Literal;
}

An export batch declaration, e.g., export * from "mod";.

extend interface ExportAllDeclaration {
    exported: Identifier | Literal | null;
}

If exported is Literal, exported.value must be a string without lone surrogate.

extend enum BinaryOperator {
    "**"
}

extend enum AssignmentOperator {
    "**="
}

extend interface Function {
    async: boolean;
}

interface AwaitExpression <: Expression {
    type: "AwaitExpression";
    argument: Expression;
}

extend interface ForOfStatement {
  await: boolean;
}

interface Statement <: Node { }

Any statement.

extend interface TemplateElement {
    value: {
        cooked: string | null;
        raw: string;
    };
}

If the template literal is tagged and the text has an invalid escape, cooked will be null, e.g., tag`\unicode and \u{55}`

extend interface ObjectPattern {
    properties: [ AssignmentProperty | RestElement ];
}

Rest properties, e.g., {a, ...rest} = obj.

Destructuring binding and assignment are not part of ES5, but all binding positions accept Pattern to allow for destructuring in ES6. Nevertheless, for ES5, the only Pattern subtype is Identifier.

interface Pattern <: Node { }

extend interface CatchClause {
    param: Pattern | null;
}

The param is null if the catch binding is omitted. E.g., try { foo() } catch { bar() }

extend interface Literal <: Expression {
    type: "Literal";
    value: string | boolean | null | number | RegExp | bigint;
}

• value property can be a BigInt value to represent BigInt literals
  such as 100n.

interface Literal <: Expression {
    type: "Literal";
    value: string | boolean | null | number | RegExp;
}

A literal token. Note that a literal can be an expression.

interface BigIntLiteral <: Literal {
  bigint: string;
}

• bigint property is the string representation of the BigInt value.
  It doesn't include the suffix n.

• In environments that don't support BigInt values, value property will be
  null as the BigInt value can't be represented natively.

interface ChainExpression <: Expression {
  type: "ChainExpression";
  expression: ChainElement;
}

interface ChainElement <: Node {
  optional: boolean;
}

extend interface CallExpression <: ChainElement {}

extend interface MemberExpression <: ChainElement {}

• The ChainExpression node is the root of optional chaining.

• The ChainExpression node contains one or more ChainElement nodes that are optional:true. On the other hand, ChainElement nodes that are optional:true belong to a ChainExpression node.

• For backward compatibility, if all ChainElement nodes of a chain are optional:false, the ChainExpression node isn't inserted as the root of the chain.

• Evaluation:

  • The ChainExpression node is evaluated to the result of the expression property's node.

  • If the callee|object property is evaluated to nullish and the optional property is true, then the node and ancestor nodes are skipped until the closest ChainExpression node, and the result of the ChainExpression node becomes undefined.

// obj.aaa.bbb
{
  "type": "MemberExpression",
  "optional": false,
  "object": {
    "type": "MemberExpression",
    "optional": false,
    "object": { "type": "Identifier", "name": "obj" },
    "property": { "type": "Identifier", "name": "aaa" }
  },
  "property": { "type": "Identifier", "name": "bbb" }
}

// obj.aaa?.bbb
{
  "type": "ChainExpression",
  "expression": {
    "type": "MemberExpression",
    "optional": true,
    "object": {
      "type": "MemberExpression",
      "optional": false,
      "object": { "type": "Identifier", "name": "obj" },
      "property": { "type": "Identifier", "name": "aaa" }
    },
    "property": { "type": "Identifier", "name": "bbb" }
  }
}

// obj?.aaa.bbb
{
  "type": "ChainExpression",
  "expression": {
    "type": "MemberExpression",
    "optional": false,
    "object": {
      "type": "MemberExpression",
      "optional": true,
      "object": { "type": "Identifier", "name": "obj" },
      "property": { "type": "Identifier", "name": "aaa" }
    },
    "property": { "type": "Identifier", "name": "bbb" }
  }
}

// obj?.aaa?.bbb
{
  "type": "ChainExpression",
  "expression": {
    "type": "MemberExpression",
    "optional": true,
    "object": {
      "type": "MemberExpression",
      "optional": true,
      "object": { "type": "Identifier", "name": "obj" },
      "property": { "type": "Identifier", "name": "aaa" }
    },
    "property": { "type": "Identifier", "name": "bbb" }
  }
}

// (obj.aaa).bbb
{
  "type": "MemberExpression",
  "optional": false,
  "object": {
    "type": "MemberExpression",
    "optional": false,
    "object": { "type": "Identifier", "name": "obj" },
    "property": { "type": "Identifier", "name": "aaa" }
  },
  "property": { "type": "Identifier", "name": "bbb" }
}

// (obj.aaa)?.bbb
{
  "type": "ChainExpression",
  "expression": {
    "type": "MemberExpression",
    "optional": true,
    "object": {
      "type": "MemberExpression",
      "optional": false,
      "object": { "type": "Identifier", "name": "obj" },
      "property": { "type": "Identifier", "name": "aaa" }
    },
    "property": { "type": "Identifier", "name": "bbb" }
  }
}

// (obj?.aaa).bbb
{
  "type": "MemberExpression",
  "optional": false,
  "object": {
    "type": "ChainExpression",
    "expression": {
      "type": "MemberExpression",
      "optional": true,
      "object": { "type": "Identifier", "name": "obj" },
      "property": { "type": "Identifier", "name": "aaa" }
    }
  },
  "property": { "type": "Identifier", "name": "bbb" }
}

// (obj?.aaa)?.bbb
{
  "type": "ChainExpression",
  "expression": {
    "type": "MemberExpression",
    "optional": true,
    "object": {
      "type": "ChainExpression",
      "expression": {
        "type": "MemberExpression",
        "optional": true,
        "object": { "type": "Identifier", "name": "obj" },
        "property": { "type": "Identifier", "name": "aaa" }
      }
    },
    "property": { "type": "Identifier", "name": "bbb" }
  }
}

interface ImportExpression <: Expression {
  type: "ImportExpression";
  source: Expression;
}

• ImportExpression node represents Dynamic Imports such as import(source).
  The source property is the importing source as similar to ImportDeclaration
  node, but it can be an arbitrary expression node.

extend enum LogicalOperator {
    "??"
}

• The operator property of the LogicalExpression node can be "??" to represent Nullish Coalescing syntax.

Existing MetaProperty node represents import.meta meta property as well.

extend interface ExportAllDeclaration {
  exported: Identifier | null;
}

The exported property contains an Identifier when a different exported name is specified using as, e.g., export * as foo from "mod";.

extend enum AssignmentOperator {
    "||=" | "&&=" | "??="
}

• AssignmentExpression node has short-circuiting behavior if the operator
  property is any of "||=","&&=", and "??=".

• See Logical Assignment Operators for details.

interface PropertyDefinition <: Node {
    type: "PropertyDefinition";
    key: Expression | PrivateIdentifier;
    value: Expression | null;
    computed: boolean;
    static: boolean;
}

• When key is a PrivateIdentifier, computed must be false.

interface PrivateIdentifier <: Node {
    type: "PrivateIdentifier";
    name: string;
}

A private identifier refers to private class elements. For a private name #a, its name is a.

extend interface MemberExpression {
    property: Expression | PrivateIdentifier;
}

• When property is a PrivateIdentifier, computed must be false.

• When object is a Super, property can not be a PrivateIdentifier.

interface StaticBlock <: BlockStatement {
    type: "StaticBlock";
}

A static block static { } is a block statement serving as an additional static initializer.

extend interface BinaryExpression <: Expression {
    left: Expression | PrivateIdentifier;
}

• left can be a private identifier (e.g. #foo) when operator is "in".

• See Ergonomic brand checks for Private Fields for details.

See Arbitrary module namespace identifier names for more details.

ESTree AST nodes are represented as Node objects, which may have any prototype inheritance but which implement the following interface:

interface Node {
    type: string;
    loc: SourceLocation | null;
}

The type field is a string representing the AST variant type. Each subtype of Node is documented below with the specific string of its type field. You can use this field to determine which interface a node implements.

The loc field represents the source location information of the node. If the node contains no information about the source location, the field is null; otherwise it is an object consisting of a start position (the position of the first character of the parsed source region) and an end position (the position of the first character after the parsed source region):

interface SourceLocation {
    source: string | null;
    start: Position;
    end: Position;
}

Each Position object consists of a line number (1-indexed) and a column number (0-indexed):

interface Position {
    line: number; // >= 1
    column: number; // >= 0
}

interface Identifier <: Expression, Pattern {
    type: "Identifier";
    name: string;
}

An identifier. Note that an identifier may be an expression or a destructuring pattern.

extend interface Identifier {
    typeAnnotation: TypeAnnotation | null;
}

The typeAnnotation property is used only in the case of variable declarations with type annotations or function arguments with type annotations.

interface RegExpLiteral <: Literal {
  regex: {
    pattern: string;
    flags: string;
  };
}

The regex property allows regexes to be represented in environments that don’t
support certain flags such as y or u. In environments that don't support
these flags value will be null as the regex can't be represented natively.

interface ExpressionStatement <: Statement {
    type: "ExpressionStatement";
    expression: Expression;
}

An expression statement, i.e., a statement consisting of a single expression.

interface Directive <: ExpressionStatement {
    expression: Literal;
    directive: string;
}

A directive from the directive prologue of a script or function.
The directive property is the raw string source of the directive without quotes.

interface BlockStatement <: Statement {
    type: "BlockStatement";
    body: [ Statement ];
}

A block statement, i.e., a sequence of statements surrounded by braces.

interface FunctionBody <: BlockStatement {
    body: [ Directive | Statement ];
}

The body of a function, which is a block statement that may begin with directives.

interface EmptyStatement <: Statement {
    type: "EmptyStatement";
}

An empty statement, i.e., a solitary semicolon.

interface DebuggerStatement <: Statement {
    type: "DebuggerStatement";
}

A debugger statement.

interface WithStatement <: Statement {
    type: "WithStatement";
    object: Expression;
    body: Statement;
}

A with statement.

interface ReturnStatement <: Statement {
    type: "ReturnStatement";
    argument: Expression | null;
}

A return statement.

interface LabeledStatement <: Statement {
    type: "LabeledStatement";
    label: Identifier;
    body: Statement;
}

A labeled statement, i.e., a statement prefixed by a break/continue label.

interface BreakStatement <: Statement {
    type: "BreakStatement";
    label: Identifier | null;
}

A break statement.

interface ContinueStatement <: Statement {
    type: "ContinueStatement";
    label: Identifier | null;
}

A continue statement.

interface IfStatement <: Statement {
    type: "IfStatement";
    test: Expression;
    consequent: Statement;
    alternate: Statement | null;
}

An if statement.

interface SwitchStatement <: Statement {
    type: "SwitchStatement";
    discriminant: Expression;
    cases: [ SwitchCase ];
}

A switch statement.

interface SwitchCase <: Node {
    type: "SwitchCase";
    test: Expression | null;
    consequent: [ Statement ];
}

A case (if test is an Expression) or default (if test === null) clause in the body of a switch statement.

interface ThrowStatement <: Statement {
    type: "ThrowStatement";
    argument: Expression;
}

A throw statement.

interface TryStatement <: Statement {
    type: "TryStatement";
    block: BlockStatement;
    handler: CatchClause | null;
    finalizer: BlockStatement | null;
}

A try statement. If handler is null then finalizer must be a BlockStatement.

interface CatchClause <: Node {
    type: "CatchClause";
    param: Pattern;
    body: BlockStatement;
}

A catch clause following a try block.

interface WhileStatement <: Statement {
    type: "WhileStatement";
    test: Expression;
    body: Statement;
}

A while statement.

interface DoWhileStatement <: Statement {
    type: "DoWhileStatement";
    body: Statement;
    test: Expression;
}

A do/while statement.

interface ForStatement <: Statement {
    type: "ForStatement";
    init: VariableDeclaration | Expression | null;
    test: Expression | null;
    update: Expression | null;
    body: Statement;
}

A for statement.

interface ForInStatement <: Statement {
    type: "ForInStatement";
    left: VariableDeclaration |  Pattern;
    right: Expression;
    body: Statement;
}

A for/in statement.

interface Declaration <: Statement { }

Any declaration node. Note that declarations are considered statements; this is because declarations can appear in any statement context.

interface FunctionDeclaration <: Function, Declaration {
    type: "FunctionDeclaration";
    id: Identifier;
}

A function declaration. Note that unlike in the parent interface Function, the id cannot be null.

interface VariableDeclarator <: Node {
    type: "VariableDeclarator";
    id: Pattern;
    init: Expression | null;
}

A variable declarator.

interface ThisExpression <: Expression {
    type: "ThisExpression";
}

A this expression.

interface ArrayExpression <: Expression {
    type: "ArrayExpression";
    elements: [ Expression | null ];
}

An array expression. An element might be null if it represents a hole in a sparse array. E.g. [1,,2].

interface ObjectExpression <: Expression {
    type: "ObjectExpression";
    properties: [ Property ];
}

An object expression.

interface Property <: Node {
    type: "Property";
    key: Literal | Identifier;
    value: Expression;
    kind: "init" | "get" | "set";
}

A literal property in an object expression can have either a string or number as its value. Ordinary property initializers have a kind value "init"; getters and setters have the kind values "get" and "set", respectively.

interface FunctionExpression <: Function, Expression {
    type: "FunctionExpression";
}

A function expression.

interface UnaryExpression <: Expression {
    type: "UnaryExpression";
    operator: UnaryOperator;
    prefix: boolean;
    argument: Expression;
}

A unary operator expression.

enum UnaryOperator {
    "-" | "+" | "!" | "~" | "typeof" | "void" | "delete"
}

A unary operator token.

interface UpdateExpression <: Expression {
    type: "UpdateExpression";
    operator: UpdateOperator;
    argument: Expression;
    prefix: boolean;
}

An update (increment or decrement) operator expression.

enum UpdateOperator {
    "++" | "--"
}

An update (increment or decrement) operator token.

interface BinaryExpression <: Expression {
    type: "BinaryExpression";
    operator: BinaryOperator;
    left: Expression;
    right: Expression;
}

A binary operator expression.

enum BinaryOperator {
    "==" | "!=" | "===" | "!=="
         | "<" | "<=" | ">" | ">="
         | "<<" | ">>" | ">>>"
         | "+" | "-" | "*" | "/" | "%"
         | "|" | "^" | "&" | "in"
         | "instanceof"
}

A binary operator token.

interface AssignmentExpression <: Expression {
    type: "AssignmentExpression";
    operator: AssignmentOperator;
    left: Pattern | Expression;
    right: Expression;
}

An assignment operator expression.

enum AssignmentOperator {
    "=" | "+=" | "-=" | "*=" | "/=" | "%="
        | "<<=" | ">>=" | ">>>="
        | "|=" | "^=" | "&="
}

An assignment operator token.

interface LogicalExpression <: Expression {
    type: "LogicalExpression";
    operator: LogicalOperator;
    left: Expression;
    right: Expression;
}

A logical operator expression.

enum LogicalOperator {
    "||" | "&&"
}

A logical operator token.

interface MemberExpression <: Expression, Pattern {
    type: "MemberExpression";
    object: Expression;
    property: Expression;
    computed: boolean;
}

A member expression. If computed is true, the node corresponds to a computed (a[b]) member expression and property is an Expression. If computed is false, the node corresponds to a static (a.b) member expression and property is an Identifier.

interface ConditionalExpression <: Expression {
    type: "ConditionalExpression";
    test: Expression;
    alternate: Expression;
    consequent: Expression;
}

A conditional expression, i.e., a ternary ?/: expression.

interface CallExpression <: Expression {
    type: "CallExpression";
    callee: Expression;
    arguments: [ Expression ];
}

A function or method call expression.

interface NewExpression <: Expression {
    type: "NewExpression";
    callee: Expression;
    arguments: [ Expression ];
}

A new expression.

interface SequenceExpression <: Expression {
    type: "SequenceExpression";
    expressions: [ Expression ];
}

A sequence expression, i.e., a comma-separated sequence of expressions.

interface TypeAnnotation <: Node { }

Any type annotation.