@types/estree

  • Version 0.0.50
  • Published
  • 23.9 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>;

                                                                                                                                                                    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 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
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 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>