@types/estree

  • Version 0.0.51
  • Published
  • 24 kB
  • No dependencies
  • MIT license

Install

npm i @types/estree
yarn add @types/estree
pnpm add @types/estree

Overview

TypeScript definitions for ESTree AST specification

Index

Interfaces

Type Aliases

Interfaces

interface ArrayExpression

interface ArrayExpression extends BaseExpression {}

    property elements

    elements: Array<Expression | SpreadElement | null>;

      property type

      type: 'ArrayExpression';

        interface ArrayPattern

        interface ArrayPattern extends BasePattern {}

          property elements

          elements: Array<Pattern | null>;

            property type

            type: 'ArrayPattern';

              interface ArrowFunctionExpression

              interface ArrowFunctionExpression extends BaseExpression, BaseFunction {}

                property body

                body: BlockStatement | Expression;

                  property expression

                  expression: boolean;

                    property type

                    type: 'ArrowFunctionExpression';

                      interface AssignmentExpression

                      interface AssignmentExpression extends BaseExpression {}

                        property left

                        left: Pattern | MemberExpression;

                          property operator

                          operator: AssignmentOperator;

                            property right

                            right: Expression;

                              property type

                              type: 'AssignmentExpression';

                                interface AssignmentPattern

                                interface AssignmentPattern extends BasePattern {}

                                  property left

                                  left: Pattern;

                                    property right

                                    right: Expression;

                                      property type

                                      type: 'AssignmentPattern';

                                        interface AssignmentProperty

                                        interface AssignmentProperty extends Property {}

                                          property kind

                                          kind: 'init';

                                            property method

                                            method: boolean;

                                              property value

                                              value: Pattern;

                                                interface AwaitExpression

                                                interface AwaitExpression extends BaseExpression {}

                                                  property argument

                                                  argument: Expression;

                                                    property type

                                                    type: 'AwaitExpression';

                                                      interface BaseCallExpression

                                                      interface BaseCallExpression extends BaseExpression {}

                                                        property arguments

                                                        arguments: Array<Expression | SpreadElement>;

                                                          property callee

                                                          callee: Expression | Super;

                                                            interface BaseClass

                                                            interface BaseClass extends BaseNode {}

                                                              property body

                                                              body: ClassBody;

                                                                property superClass

                                                                superClass?: Expression | null | undefined;

                                                                  interface BaseDeclaration

                                                                  interface BaseDeclaration extends BaseStatement {}

                                                                    interface BaseExpression

                                                                    interface BaseExpression extends BaseNode {}

                                                                      interface BaseForXStatement

                                                                      interface BaseForXStatement extends BaseStatement {}

                                                                        property body

                                                                        body: Statement;

                                                                          property left

                                                                          left: VariableDeclaration | Pattern;

                                                                            property right

                                                                            right: Expression;

                                                                              interface BaseFunction

                                                                              interface BaseFunction extends BaseNode {}

                                                                                property async

                                                                                async?: boolean | undefined;

                                                                                  property body

                                                                                  body: BlockStatement | Expression;

                                                                                    property generator

                                                                                    generator?: boolean | undefined;

                                                                                      property params

                                                                                      params: Array<Pattern>;

                                                                                        interface BaseModuleDeclaration

                                                                                        interface BaseModuleDeclaration extends BaseNode {}

                                                                                          interface BaseModuleSpecifier

                                                                                          interface BaseModuleSpecifier extends BaseNode {}

                                                                                            property local

                                                                                            local: Identifier;

                                                                                              interface BaseNode

                                                                                              interface BaseNode extends BaseNodeWithoutComments {}

                                                                                                property leadingComments

                                                                                                leadingComments?: Array<Comment> | undefined;

                                                                                                  property trailingComments

                                                                                                  trailingComments?: Array<Comment> | undefined;

                                                                                                    interface BaseNodeWithoutComments

                                                                                                    interface BaseNodeWithoutComments {}

                                                                                                      property loc

                                                                                                      loc?: SourceLocation | null | undefined;

                                                                                                        property range

                                                                                                        range?: [number, number] | undefined;

                                                                                                          property type

                                                                                                          type: string;

                                                                                                            interface BasePattern

                                                                                                            interface BasePattern extends BaseNode {}

                                                                                                              interface BaseStatement

                                                                                                              interface BaseStatement extends BaseNode {}

                                                                                                                interface BigIntLiteral

                                                                                                                interface BigIntLiteral extends BaseNode, BaseExpression {}

                                                                                                                  property bigint

                                                                                                                  bigint: string;

                                                                                                                    property raw

                                                                                                                    raw?: string | undefined;

                                                                                                                      property type

                                                                                                                      type: 'Literal';

                                                                                                                        property value

                                                                                                                        value?: bigint | null | undefined;

                                                                                                                          interface BinaryExpression

                                                                                                                          interface BinaryExpression extends BaseExpression {}

                                                                                                                            property left

                                                                                                                            left: Expression;

                                                                                                                              property operator

                                                                                                                              operator: BinaryOperator;

                                                                                                                                property right

                                                                                                                                right: Expression;

                                                                                                                                  property type

                                                                                                                                  type: 'BinaryExpression';

                                                                                                                                    interface BlockStatement

                                                                                                                                    interface BlockStatement extends BaseStatement {}

                                                                                                                                      property body

                                                                                                                                      body: Array<Statement>;

                                                                                                                                        property innerComments

                                                                                                                                        innerComments?: Array<Comment> | undefined;

                                                                                                                                          property type

                                                                                                                                          type: 'BlockStatement';

                                                                                                                                            interface BreakStatement

                                                                                                                                            interface BreakStatement extends BaseStatement {}

                                                                                                                                              property label

                                                                                                                                              label?: Identifier | null | undefined;

                                                                                                                                                property type

                                                                                                                                                type: 'BreakStatement';

                                                                                                                                                  interface CatchClause

                                                                                                                                                  interface CatchClause extends BaseNode {}

                                                                                                                                                    property body

                                                                                                                                                    body: BlockStatement;

                                                                                                                                                      property param

                                                                                                                                                      param: Pattern | null;

                                                                                                                                                        property type

                                                                                                                                                        type: 'CatchClause';

                                                                                                                                                          interface ChainExpression

                                                                                                                                                          interface ChainExpression extends BaseExpression {}

                                                                                                                                                            property expression

                                                                                                                                                            expression: ChainElement;

                                                                                                                                                              property type

                                                                                                                                                              type: 'ChainExpression';

                                                                                                                                                                interface ClassBody

                                                                                                                                                                interface ClassBody extends BaseNode {}

                                                                                                                                                                  property body

                                                                                                                                                                  body: Array<MethodDefinition | PropertyDefinition | StaticBlock>;

                                                                                                                                                                    property type

                                                                                                                                                                    type: 'ClassBody';

                                                                                                                                                                      interface ClassDeclaration

                                                                                                                                                                      interface ClassDeclaration extends BaseClass, BaseDeclaration {}

                                                                                                                                                                        property id

                                                                                                                                                                        id: Identifier | null;
                                                                                                                                                                        • It is null when a class declaration is a part of the export default class statement

                                                                                                                                                                        property type

                                                                                                                                                                        type: 'ClassDeclaration';

                                                                                                                                                                          interface ClassExpression

                                                                                                                                                                          interface ClassExpression extends BaseClass, BaseExpression {}

                                                                                                                                                                            property id

                                                                                                                                                                            id?: Identifier | null | undefined;

                                                                                                                                                                              property type

                                                                                                                                                                              type: 'ClassExpression';

                                                                                                                                                                                interface Comment

                                                                                                                                                                                interface Comment extends BaseNodeWithoutComments {}

                                                                                                                                                                                  property type

                                                                                                                                                                                  type: 'Line' | 'Block';

                                                                                                                                                                                    property value

                                                                                                                                                                                    value: string;

                                                                                                                                                                                      interface ConditionalExpression

                                                                                                                                                                                      interface ConditionalExpression extends BaseExpression {}

                                                                                                                                                                                        property alternate

                                                                                                                                                                                        alternate: Expression;

                                                                                                                                                                                          property consequent

                                                                                                                                                                                          consequent: Expression;

                                                                                                                                                                                            property test

                                                                                                                                                                                            test: Expression;

                                                                                                                                                                                              property type

                                                                                                                                                                                              type: 'ConditionalExpression';

                                                                                                                                                                                                interface ContinueStatement

                                                                                                                                                                                                interface ContinueStatement extends BaseStatement {}

                                                                                                                                                                                                  property label

                                                                                                                                                                                                  label?: Identifier | null | undefined;

                                                                                                                                                                                                    property type

                                                                                                                                                                                                    type: 'ContinueStatement';

                                                                                                                                                                                                      interface DebuggerStatement

                                                                                                                                                                                                      interface DebuggerStatement extends BaseStatement {}

                                                                                                                                                                                                        property type

                                                                                                                                                                                                        type: 'DebuggerStatement';

                                                                                                                                                                                                          interface Directive

                                                                                                                                                                                                          interface Directive extends BaseNode {}

                                                                                                                                                                                                            property directive

                                                                                                                                                                                                            directive: string;

                                                                                                                                                                                                              property expression

                                                                                                                                                                                                              expression: Literal;

                                                                                                                                                                                                                property type

                                                                                                                                                                                                                type: 'ExpressionStatement';

                                                                                                                                                                                                                  interface DoWhileStatement

                                                                                                                                                                                                                  interface DoWhileStatement extends BaseStatement {}

                                                                                                                                                                                                                    property body

                                                                                                                                                                                                                    body: Statement;

                                                                                                                                                                                                                      property test

                                                                                                                                                                                                                      test: Expression;

                                                                                                                                                                                                                        property type

                                                                                                                                                                                                                        type: 'DoWhileStatement';

                                                                                                                                                                                                                          interface EmptyStatement

                                                                                                                                                                                                                          interface EmptyStatement extends BaseStatement {}

                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                            type: 'EmptyStatement';

                                                                                                                                                                                                                              interface ExportAllDeclaration

                                                                                                                                                                                                                              interface ExportAllDeclaration extends BaseModuleDeclaration {}

                                                                                                                                                                                                                                property exported

                                                                                                                                                                                                                                exported: Identifier | null;

                                                                                                                                                                                                                                  property source

                                                                                                                                                                                                                                  source: Literal;

                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                    type: 'ExportAllDeclaration';

                                                                                                                                                                                                                                      interface ExportDefaultDeclaration

                                                                                                                                                                                                                                      interface ExportDefaultDeclaration extends BaseModuleDeclaration {}

                                                                                                                                                                                                                                        property declaration

                                                                                                                                                                                                                                        declaration: Declaration | Expression;

                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                          type: 'ExportDefaultDeclaration';

                                                                                                                                                                                                                                            interface ExportNamedDeclaration

                                                                                                                                                                                                                                            interface ExportNamedDeclaration extends BaseModuleDeclaration {}

                                                                                                                                                                                                                                              property declaration

                                                                                                                                                                                                                                              declaration?: Declaration | null | undefined;

                                                                                                                                                                                                                                                property source

                                                                                                                                                                                                                                                source?: Literal | null | undefined;

                                                                                                                                                                                                                                                  property specifiers

                                                                                                                                                                                                                                                  specifiers: Array<ExportSpecifier>;

                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                    type: 'ExportNamedDeclaration';

                                                                                                                                                                                                                                                      interface ExportSpecifier

                                                                                                                                                                                                                                                      interface ExportSpecifier extends BaseModuleSpecifier {}

                                                                                                                                                                                                                                                        property exported

                                                                                                                                                                                                                                                        exported: Identifier;

                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                          type: 'ExportSpecifier';

                                                                                                                                                                                                                                                            interface ExpressionStatement

                                                                                                                                                                                                                                                            interface ExpressionStatement extends BaseStatement {}

                                                                                                                                                                                                                                                              property expression

                                                                                                                                                                                                                                                              expression: Expression;

                                                                                                                                                                                                                                                                property type

                                                                                                                                                                                                                                                                type: 'ExpressionStatement';

                                                                                                                                                                                                                                                                  interface ForInStatement

                                                                                                                                                                                                                                                                  interface ForInStatement extends BaseForXStatement {}

                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                    type: 'ForInStatement';

                                                                                                                                                                                                                                                                      interface ForOfStatement

                                                                                                                                                                                                                                                                      interface ForOfStatement extends BaseForXStatement {}

                                                                                                                                                                                                                                                                        property await

                                                                                                                                                                                                                                                                        await: boolean;

                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                          type: 'ForOfStatement';

                                                                                                                                                                                                                                                                            interface ForStatement

                                                                                                                                                                                                                                                                            interface ForStatement extends BaseStatement {}

                                                                                                                                                                                                                                                                              property body

                                                                                                                                                                                                                                                                              body: Statement;

                                                                                                                                                                                                                                                                                property init

                                                                                                                                                                                                                                                                                init?: VariableDeclaration | Expression | null | undefined;

                                                                                                                                                                                                                                                                                  property test

                                                                                                                                                                                                                                                                                  test?: Expression | null | undefined;

                                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                                    type: 'ForStatement';

                                                                                                                                                                                                                                                                                      property update

                                                                                                                                                                                                                                                                                      update?: Expression | null | undefined;

                                                                                                                                                                                                                                                                                        interface FunctionDeclaration

                                                                                                                                                                                                                                                                                        interface FunctionDeclaration extends BaseFunction, BaseDeclaration {}

                                                                                                                                                                                                                                                                                          property body

                                                                                                                                                                                                                                                                                          body: BlockStatement;

                                                                                                                                                                                                                                                                                            property id

                                                                                                                                                                                                                                                                                            id: Identifier | null;
                                                                                                                                                                                                                                                                                            • It is null when a function declaration is a part of the export default function statement

                                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                                            type: 'FunctionDeclaration';

                                                                                                                                                                                                                                                                                              interface FunctionExpression

                                                                                                                                                                                                                                                                                              interface FunctionExpression extends BaseFunction, BaseExpression {}

                                                                                                                                                                                                                                                                                                property body

                                                                                                                                                                                                                                                                                                body: BlockStatement;

                                                                                                                                                                                                                                                                                                  property id

                                                                                                                                                                                                                                                                                                  id?: Identifier | null | undefined;

                                                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                                                    type: 'FunctionExpression';

                                                                                                                                                                                                                                                                                                      interface Identifier

                                                                                                                                                                                                                                                                                                      interface Identifier extends BaseNode, BaseExpression, BasePattern {}

                                                                                                                                                                                                                                                                                                        property name

                                                                                                                                                                                                                                                                                                        name: string;

                                                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                                                          type: 'Identifier';

                                                                                                                                                                                                                                                                                                            interface IfStatement

                                                                                                                                                                                                                                                                                                            interface IfStatement extends BaseStatement {}

                                                                                                                                                                                                                                                                                                              property alternate

                                                                                                                                                                                                                                                                                                              alternate?: Statement | null | undefined;

                                                                                                                                                                                                                                                                                                                property consequent

                                                                                                                                                                                                                                                                                                                consequent: Statement;

                                                                                                                                                                                                                                                                                                                  property test

                                                                                                                                                                                                                                                                                                                  test: Expression;

                                                                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                                                                    type: 'IfStatement';

                                                                                                                                                                                                                                                                                                                      interface ImportDeclaration

                                                                                                                                                                                                                                                                                                                      interface ImportDeclaration extends BaseModuleDeclaration {}

                                                                                                                                                                                                                                                                                                                        property source

                                                                                                                                                                                                                                                                                                                        source: Literal;

                                                                                                                                                                                                                                                                                                                          property specifiers

                                                                                                                                                                                                                                                                                                                          specifiers: Array<
                                                                                                                                                                                                                                                                                                                          ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier
                                                                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                                                                            type: 'ImportDeclaration';

                                                                                                                                                                                                                                                                                                                              interface ImportDefaultSpecifier

                                                                                                                                                                                                                                                                                                                              interface ImportDefaultSpecifier extends BaseModuleSpecifier {}

                                                                                                                                                                                                                                                                                                                                property type

                                                                                                                                                                                                                                                                                                                                type: 'ImportDefaultSpecifier';

                                                                                                                                                                                                                                                                                                                                  interface ImportExpression

                                                                                                                                                                                                                                                                                                                                  interface ImportExpression extends BaseExpression {}

                                                                                                                                                                                                                                                                                                                                    property source

                                                                                                                                                                                                                                                                                                                                    source: Expression;

                                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                                      type: 'ImportExpression';

                                                                                                                                                                                                                                                                                                                                        interface ImportNamespaceSpecifier

                                                                                                                                                                                                                                                                                                                                        interface ImportNamespaceSpecifier extends BaseModuleSpecifier {}

                                                                                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                                                                                          type: 'ImportNamespaceSpecifier';

                                                                                                                                                                                                                                                                                                                                            interface ImportSpecifier

                                                                                                                                                                                                                                                                                                                                            interface ImportSpecifier extends BaseModuleSpecifier {}

                                                                                                                                                                                                                                                                                                                                              property imported

                                                                                                                                                                                                                                                                                                                                              imported: Identifier;

                                                                                                                                                                                                                                                                                                                                                property type

                                                                                                                                                                                                                                                                                                                                                type: 'ImportSpecifier';

                                                                                                                                                                                                                                                                                                                                                  interface LabeledStatement

                                                                                                                                                                                                                                                                                                                                                  interface LabeledStatement extends BaseStatement {}

                                                                                                                                                                                                                                                                                                                                                    property body

                                                                                                                                                                                                                                                                                                                                                    body: Statement;

                                                                                                                                                                                                                                                                                                                                                      property label

                                                                                                                                                                                                                                                                                                                                                      label: Identifier;

                                                                                                                                                                                                                                                                                                                                                        property type

                                                                                                                                                                                                                                                                                                                                                        type: 'LabeledStatement';

                                                                                                                                                                                                                                                                                                                                                          interface LogicalExpression

                                                                                                                                                                                                                                                                                                                                                          interface LogicalExpression extends BaseExpression {}

                                                                                                                                                                                                                                                                                                                                                            property left

                                                                                                                                                                                                                                                                                                                                                            left: Expression;

                                                                                                                                                                                                                                                                                                                                                              property operator

                                                                                                                                                                                                                                                                                                                                                              operator: LogicalOperator;

                                                                                                                                                                                                                                                                                                                                                                property right

                                                                                                                                                                                                                                                                                                                                                                right: Expression;

                                                                                                                                                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                                                                                                                                                  type: 'LogicalExpression';

                                                                                                                                                                                                                                                                                                                                                                    interface MemberExpression

                                                                                                                                                                                                                                                                                                                                                                    interface MemberExpression extends BaseExpression, BasePattern {}

                                                                                                                                                                                                                                                                                                                                                                      property computed

                                                                                                                                                                                                                                                                                                                                                                      computed: boolean;

                                                                                                                                                                                                                                                                                                                                                                        property object

                                                                                                                                                                                                                                                                                                                                                                        object: Expression | Super;

                                                                                                                                                                                                                                                                                                                                                                          property optional

                                                                                                                                                                                                                                                                                                                                                                          optional: boolean;

                                                                                                                                                                                                                                                                                                                                                                            property property

                                                                                                                                                                                                                                                                                                                                                                            property: Expression | PrivateIdentifier;

                                                                                                                                                                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                                                                                                                                                                              type: 'MemberExpression';

                                                                                                                                                                                                                                                                                                                                                                                interface MetaProperty

                                                                                                                                                                                                                                                                                                                                                                                interface MetaProperty extends BaseExpression {}

                                                                                                                                                                                                                                                                                                                                                                                  property meta

                                                                                                                                                                                                                                                                                                                                                                                  meta: Identifier;

                                                                                                                                                                                                                                                                                                                                                                                    property property

                                                                                                                                                                                                                                                                                                                                                                                    property: Identifier;

                                                                                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                                                                                      type: 'MetaProperty';

                                                                                                                                                                                                                                                                                                                                                                                        interface MethodDefinition

                                                                                                                                                                                                                                                                                                                                                                                        interface MethodDefinition extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                                          property computed

                                                                                                                                                                                                                                                                                                                                                                                          computed: boolean;

                                                                                                                                                                                                                                                                                                                                                                                            property key

                                                                                                                                                                                                                                                                                                                                                                                            key: Expression | PrivateIdentifier;

                                                                                                                                                                                                                                                                                                                                                                                              property kind

                                                                                                                                                                                                                                                                                                                                                                                              kind: 'constructor' | 'method' | 'get' | 'set';

                                                                                                                                                                                                                                                                                                                                                                                                property static

                                                                                                                                                                                                                                                                                                                                                                                                static: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                                                                                                                                                                                  type: 'MethodDefinition';

                                                                                                                                                                                                                                                                                                                                                                                                    property value

                                                                                                                                                                                                                                                                                                                                                                                                    value: FunctionExpression;

                                                                                                                                                                                                                                                                                                                                                                                                      interface NewExpression

                                                                                                                                                                                                                                                                                                                                                                                                      interface NewExpression extends BaseCallExpression {}

                                                                                                                                                                                                                                                                                                                                                                                                        property type

                                                                                                                                                                                                                                                                                                                                                                                                        type: 'NewExpression';

                                                                                                                                                                                                                                                                                                                                                                                                          interface ObjectExpression

                                                                                                                                                                                                                                                                                                                                                                                                          interface ObjectExpression extends BaseExpression {}

                                                                                                                                                                                                                                                                                                                                                                                                            property properties

                                                                                                                                                                                                                                                                                                                                                                                                            properties: Array<Property | SpreadElement>;

                                                                                                                                                                                                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                                                                                                                                                                                                              type: 'ObjectExpression';

                                                                                                                                                                                                                                                                                                                                                                                                                interface ObjectPattern

                                                                                                                                                                                                                                                                                                                                                                                                                interface ObjectPattern extends BasePattern {}

                                                                                                                                                                                                                                                                                                                                                                                                                  property properties

                                                                                                                                                                                                                                                                                                                                                                                                                  properties: Array<AssignmentProperty | RestElement>;

                                                                                                                                                                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                                                                                                                                                                    type: 'ObjectPattern';

                                                                                                                                                                                                                                                                                                                                                                                                                      interface Position

                                                                                                                                                                                                                                                                                                                                                                                                                      interface Position {}

                                                                                                                                                                                                                                                                                                                                                                                                                        property column

                                                                                                                                                                                                                                                                                                                                                                                                                        column: number;
                                                                                                                                                                                                                                                                                                                                                                                                                        • >= 0

                                                                                                                                                                                                                                                                                                                                                                                                                        property line

                                                                                                                                                                                                                                                                                                                                                                                                                        line: number;
                                                                                                                                                                                                                                                                                                                                                                                                                        • >= 1

                                                                                                                                                                                                                                                                                                                                                                                                                        interface PrivateIdentifier

                                                                                                                                                                                                                                                                                                                                                                                                                        interface PrivateIdentifier extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                                                                          property name

                                                                                                                                                                                                                                                                                                                                                                                                                          name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                                                                                                                                                                            type: 'PrivateIdentifier';

                                                                                                                                                                                                                                                                                                                                                                                                                              interface Program

                                                                                                                                                                                                                                                                                                                                                                                                                              interface Program extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                                                                                property body

                                                                                                                                                                                                                                                                                                                                                                                                                                body: Array<Directive | Statement | ModuleDeclaration>;

                                                                                                                                                                                                                                                                                                                                                                                                                                  property comments

                                                                                                                                                                                                                                                                                                                                                                                                                                  comments?: Array<Comment> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                    property sourceType

                                                                                                                                                                                                                                                                                                                                                                                                                                    sourceType: 'script' | 'module';

                                                                                                                                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                                                                                                                                      type: 'Program';

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Property

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Property extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                                                                                          property computed

                                                                                                                                                                                                                                                                                                                                                                                                                                          computed: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                            property key

                                                                                                                                                                                                                                                                                                                                                                                                                                            key: Expression | PrivateIdentifier;

                                                                                                                                                                                                                                                                                                                                                                                                                                              property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                              kind: 'init' | 'get' | 'set';

                                                                                                                                                                                                                                                                                                                                                                                                                                                property method

                                                                                                                                                                                                                                                                                                                                                                                                                                                method: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property shorthand

                                                                                                                                                                                                                                                                                                                                                                                                                                                  shorthand: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                    type: 'Property';

                                                                                                                                                                                                                                                                                                                                                                                                                                                      property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                      value: Expression | Pattern;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface PropertyDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface PropertyDefinition extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property computed

                                                                                                                                                                                                                                                                                                                                                                                                                                                          computed: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property key

                                                                                                                                                                                                                                                                                                                                                                                                                                                            key: Expression | PrivateIdentifier;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              property static

                                                                                                                                                                                                                                                                                                                                                                                                                                                              static: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                type: 'PropertyDefinition';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  value?: Expression | null | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface RegExpLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface RegExpLiteral extends BaseNode, BaseExpression {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property raw

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      raw?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property regex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        regex: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        pattern: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        flags: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: 'Literal';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            value?: RegExp | null | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface RestElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface RestElement extends BasePattern {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property argument

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                argument: Pattern;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type: 'RestElement';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ReturnStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ReturnStatement extends BaseStatement {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property argument

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      argument?: Expression | null | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type: 'ReturnStatement';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface SequenceExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface SequenceExpression extends BaseExpression {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property expressions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            expressions: Array<Expression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type: 'SequenceExpression';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface SimpleCallExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface SimpleCallExpression extends BaseCallExpression {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property optional

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  optional: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type: 'CallExpression';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface SimpleLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface SimpleLiteral extends BaseNode, BaseExpression {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property raw

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        raw?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: 'Literal';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            value: string | boolean | number | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface SourceLocation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface SourceLocation {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property end

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                end: Position;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property source

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  source?: string | null | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property start

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    start: Position;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface SpreadElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface SpreadElement extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property argument

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        argument: Expression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: 'SpreadElement';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface StaticBlock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface StaticBlock extends Omit<BlockStatement, 'type'> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type: 'StaticBlock';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Super

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Super extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type: 'Super';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface SwitchCase

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface SwitchCase extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property consequent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      consequent: Array<Statement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property test

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        test?: Expression | null | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: 'SwitchCase';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface SwitchStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface SwitchStatement extends BaseStatement {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property cases

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              cases: Array<SwitchCase>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property discriminant

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                discriminant: Expression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type: 'SwitchStatement';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface TaggedTemplateExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface TaggedTemplateExpression extends BaseExpression {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property quasi

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      quasi: TemplateLiteral;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property tag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        tag: Expression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: 'TaggedTemplateExpression';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface TemplateElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface TemplateElement extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property tail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              tail: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type: 'TemplateElement';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  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 TemplateLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface TemplateLiteral extends BaseExpression {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property expressions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      expressions: Array<Expression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property quasis

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        quasis: Array<TemplateElement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: 'TemplateLiteral';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ThisExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ThisExpression extends BaseExpression {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type: 'ThisExpression';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ThrowStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ThrowStatement extends BaseStatement {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property argument

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  argument: Expression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type: 'ThrowStatement';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface TryStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface TryStatement extends BaseStatement {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property block

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        block: BlockStatement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property finalizer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          finalizer?: BlockStatement | null | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property handler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            handler?: CatchClause | null | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type: 'TryStatement';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface UnaryExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface UnaryExpression extends BaseExpression {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property argument

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  argument: Expression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property operator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    operator: UnaryOperator;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property prefix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      prefix: true;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type: 'UnaryExpression';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface UpdateExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface UpdateExpression extends BaseExpression {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property argument

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            argument: Expression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property operator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              operator: UpdateOperator;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property prefix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                prefix: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type: 'UpdateExpression';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface VariableDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface VariableDeclaration extends BaseDeclaration {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property declarations

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      declarations: Array<VariableDeclarator>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        kind: 'var' | 'let' | 'const';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: 'VariableDeclaration';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface VariableDeclarator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface VariableDeclarator extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              id: Pattern;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property init

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                init?: Expression | null | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type: 'VariableDeclarator';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface WhileStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface WhileStatement extends BaseStatement {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property body

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      body: Statement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property test

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        test: Expression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: 'WhileStatement';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface WithStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface WithStatement extends BaseStatement {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property body

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              body: Statement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                object: Expression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type: 'WithStatement';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface YieldExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface YieldExpression extends BaseExpression {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property argument

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      argument?: Expression | null | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property delegate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        delegate: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: 'YieldExpression';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type Aliases

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type AssignmentOperator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type AssignmentOperator =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | '='
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | '+='
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | '-='
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | '*='
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | '/='
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | '%='
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | '**='
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | '<<='
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | '>>='
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | '>>>='
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | '|='
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | '^='
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | '&=';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type BinaryOperator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type BinaryOperator =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | '=='
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | '!='
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | '==='
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | '!=='
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | '<'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | '<='
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | '>'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | '>='
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | '<<'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | '>>'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | '>>>'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | '+'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | '-'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | '*'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | '/'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | '%'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | '**'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | '|'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | '^'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | '&'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'in'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'instanceof';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type CallExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type CallExpression = SimpleCallExpression | NewExpression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ChainElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ChainElement = SimpleCallExpression | MemberExpression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type Class

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type Class = ClassDeclaration | ClassExpression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Declaration = FunctionDeclaration | VariableDeclaration | ClassDeclaration;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type Expression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type Expression =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | ThisExpression
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | ArrayExpression
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | ObjectExpression
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | FunctionExpression
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | ArrowFunctionExpression
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | YieldExpression
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | Literal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | UnaryExpression
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | UpdateExpression
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | BinaryExpression
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | AssignmentExpression
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | LogicalExpression
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | MemberExpression
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | ConditionalExpression
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | CallExpression
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | NewExpression
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | SequenceExpression
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | TemplateLiteral
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | TaggedTemplateExpression
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | ClassExpression
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | MetaProperty
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | Identifier
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | AwaitExpression
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | ImportExpression
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | ChainExpression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Function

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Function = FunctionDeclaration | FunctionExpression | ArrowFunctionExpression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Literal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Literal = SimpleLiteral | RegExpLiteral | BigIntLiteral;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type LogicalOperator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type LogicalOperator = '||' | '&&' | '??';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ModuleDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ModuleDeclaration =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | ImportDeclaration
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | ExportNamedDeclaration
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | ExportDefaultDeclaration
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | ExportAllDeclaration;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ModuleSpecifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ModuleSpecifier =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | ImportSpecifier
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | ImportDefaultSpecifier
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | ImportNamespaceSpecifier
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | ExportSpecifier;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type Node

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type Node =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | Identifier
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | Literal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | Program
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | Function
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | SwitchCase
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | CatchClause
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | VariableDeclarator
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | Statement
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | Expression
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | PrivateIdentifier
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | Property
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | PropertyDefinition
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | AssignmentProperty
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | Super
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | TemplateElement
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | SpreadElement
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | Pattern
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | ClassBody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | Class
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | MethodDefinition
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | ModuleDeclaration
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | ModuleSpecifier;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Pattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Pattern =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | Identifier
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | ObjectPattern
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | ArrayPattern
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | RestElement
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | AssignmentPattern
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | MemberExpression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type Statement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type Statement =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | ExpressionStatement
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | BlockStatement
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | StaticBlock
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | EmptyStatement
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | DebuggerStatement
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | WithStatement
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | ReturnStatement
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | LabeledStatement
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | BreakStatement
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | ContinueStatement
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | IfStatement
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | SwitchStatement
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | ThrowStatement
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | TryStatement
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | WhileStatement
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | DoWhileStatement
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | ForStatement
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | ForInStatement
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | ForOfStatement
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | Declaration;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type UnaryOperator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type UnaryOperator = '-' | '+' | '!' | '~' | 'typeof' | 'void' | 'delete';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type UpdateOperator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type UpdateOperator = '++' | '--';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Package Files (1)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              No dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Dev Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              No dev dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              No peer dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Badge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@types/estree.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@types/estree)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • HTML
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <a href="https://www.jsdocs.io/package/@types/estree"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>