@types/estree

  • Version 1.0.0
  • Published
  • 25.7 kB
  • No dependencies
  • MIT license

Install

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

Overview

TypeScript definitions for estree

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: 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?: Comment[] | undefined;

                                                                                                  property trailingComments

                                                                                                  trailingComments?: 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: Statement[];

                                                                                                                                        property innerComments

                                                                                                                                        innerComments?: Comment[] | undefined;

                                                                                                                                          property type

                                                                                                                                          type: 'BlockStatement';

                                                                                                                                            interface BreakStatement

                                                                                                                                            interface BreakStatement extends BaseStatement {}

                                                                                                                                              property label

                                                                                                                                              label?: Identifier | null | undefined;

                                                                                                                                                property type

                                                                                                                                                type: 'BreakStatement';

                                                                                                                                                  interface CatchClause

                                                                                                                                                  interface CatchClause extends BaseNode {}

                                                                                                                                                    property body

                                                                                                                                                    body: BlockStatement;

                                                                                                                                                      property param

                                                                                                                                                      param: Pattern | null;

                                                                                                                                                        property type

                                                                                                                                                        type: 'CatchClause';

                                                                                                                                                          interface ChainExpression

                                                                                                                                                          interface ChainExpression extends BaseExpression {}

                                                                                                                                                            property expression

                                                                                                                                                            expression: ChainElement;

                                                                                                                                                              property type

                                                                                                                                                              type: 'ChainExpression';

                                                                                                                                                                interface ClassBody

                                                                                                                                                                interface ClassBody extends BaseNode {}

                                                                                                                                                                  property body

                                                                                                                                                                  body: Array<MethodDefinition | PropertyDefinition | StaticBlock>;

                                                                                                                                                                    property type

                                                                                                                                                                    type: 'ClassBody';

                                                                                                                                                                      interface ClassDeclaration

                                                                                                                                                                      interface ClassDeclaration extends BaseClass, BaseDeclaration {}

                                                                                                                                                                        property id

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

                                                                                                                                                                        property type

                                                                                                                                                                        type: 'ClassDeclaration';

                                                                                                                                                                          interface ClassExpression

                                                                                                                                                                          interface ClassExpression extends BaseClass, BaseExpression {}

                                                                                                                                                                            property id

                                                                                                                                                                            id?: Identifier | null | undefined;

                                                                                                                                                                              property type

                                                                                                                                                                              type: 'ClassExpression';

                                                                                                                                                                                interface Comment

                                                                                                                                                                                interface Comment extends BaseNodeWithoutComments {}

                                                                                                                                                                                  property type

                                                                                                                                                                                  type: 'Line' | 'Block';

                                                                                                                                                                                    property value

                                                                                                                                                                                    value: string;

                                                                                                                                                                                      interface ConditionalExpression

                                                                                                                                                                                      interface ConditionalExpression extends BaseExpression {}

                                                                                                                                                                                        property alternate

                                                                                                                                                                                        alternate: Expression;

                                                                                                                                                                                          property consequent

                                                                                                                                                                                          consequent: Expression;

                                                                                                                                                                                            property test

                                                                                                                                                                                            test: Expression;

                                                                                                                                                                                              property type

                                                                                                                                                                                              type: 'ConditionalExpression';

                                                                                                                                                                                                interface ContinueStatement

                                                                                                                                                                                                interface ContinueStatement extends BaseStatement {}

                                                                                                                                                                                                  property label

                                                                                                                                                                                                  label?: Identifier | null | undefined;

                                                                                                                                                                                                    property type

                                                                                                                                                                                                    type: 'ContinueStatement';

                                                                                                                                                                                                      interface DebuggerStatement

                                                                                                                                                                                                      interface DebuggerStatement extends BaseStatement {}

                                                                                                                                                                                                        property type

                                                                                                                                                                                                        type: 'DebuggerStatement';

                                                                                                                                                                                                          interface Directive

                                                                                                                                                                                                          interface Directive extends BaseNode {}

                                                                                                                                                                                                            property directive

                                                                                                                                                                                                            directive: string;

                                                                                                                                                                                                              property expression

                                                                                                                                                                                                              expression: Literal;

                                                                                                                                                                                                                property type

                                                                                                                                                                                                                type: 'ExpressionStatement';

                                                                                                                                                                                                                  interface DoWhileStatement

                                                                                                                                                                                                                  interface DoWhileStatement extends BaseStatement {}

                                                                                                                                                                                                                    property body

                                                                                                                                                                                                                    body: Statement;

                                                                                                                                                                                                                      property test

                                                                                                                                                                                                                      test: Expression;

                                                                                                                                                                                                                        property type

                                                                                                                                                                                                                        type: 'DoWhileStatement';

                                                                                                                                                                                                                          interface EmptyStatement

                                                                                                                                                                                                                          interface EmptyStatement extends BaseStatement {}

                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                            type: 'EmptyStatement';

                                                                                                                                                                                                                              interface ExportAllDeclaration

                                                                                                                                                                                                                              interface ExportAllDeclaration extends BaseModuleDeclaration {}

                                                                                                                                                                                                                                property exported

                                                                                                                                                                                                                                exported: Identifier | null;

                                                                                                                                                                                                                                  property source

                                                                                                                                                                                                                                  source: Literal;

                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                    type: 'ExportAllDeclaration';

                                                                                                                                                                                                                                      interface ExportDefaultDeclaration

                                                                                                                                                                                                                                      interface ExportDefaultDeclaration extends BaseModuleDeclaration {}

                                                                                                                                                                                                                                        property declaration

                                                                                                                                                                                                                                        declaration: Declaration | Expression;

                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                          type: 'ExportDefaultDeclaration';

                                                                                                                                                                                                                                            interface ExportNamedDeclaration

                                                                                                                                                                                                                                            interface ExportNamedDeclaration extends BaseModuleDeclaration {}

                                                                                                                                                                                                                                              property declaration

                                                                                                                                                                                                                                              declaration?: Declaration | null | undefined;

                                                                                                                                                                                                                                                property source

                                                                                                                                                                                                                                                source?: Literal | null | undefined;

                                                                                                                                                                                                                                                  property specifiers

                                                                                                                                                                                                                                                  specifiers: ExportSpecifier[];

                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                    type: 'ExportNamedDeclaration';

                                                                                                                                                                                                                                                      interface ExportSpecifier

                                                                                                                                                                                                                                                      interface ExportSpecifier extends BaseModuleSpecifier {}

                                                                                                                                                                                                                                                        property exported

                                                                                                                                                                                                                                                        exported: Identifier;

                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                          type: 'ExportSpecifier';

                                                                                                                                                                                                                                                            interface ExpressionMap

                                                                                                                                                                                                                                                            interface ExpressionMap {}

                                                                                                                                                                                                                                                              property ArrayExpression

                                                                                                                                                                                                                                                              ArrayExpression: ArrayExpression;

                                                                                                                                                                                                                                                                property ArrowFunctionExpression

                                                                                                                                                                                                                                                                ArrowFunctionExpression: ArrowFunctionExpression;

                                                                                                                                                                                                                                                                  property AssignmentExpression

                                                                                                                                                                                                                                                                  AssignmentExpression: AssignmentExpression;

                                                                                                                                                                                                                                                                    property AwaitExpression

                                                                                                                                                                                                                                                                    AwaitExpression: AwaitExpression;

                                                                                                                                                                                                                                                                      property BinaryExpression

                                                                                                                                                                                                                                                                      BinaryExpression: BinaryExpression;

                                                                                                                                                                                                                                                                        property CallExpression

                                                                                                                                                                                                                                                                        CallExpression: CallExpression;

                                                                                                                                                                                                                                                                          property ChainExpression

                                                                                                                                                                                                                                                                          ChainExpression: ChainExpression;

                                                                                                                                                                                                                                                                            property ClassExpression

                                                                                                                                                                                                                                                                            ClassExpression: ClassExpression;

                                                                                                                                                                                                                                                                              property ConditionalExpression

                                                                                                                                                                                                                                                                              ConditionalExpression: ConditionalExpression;

                                                                                                                                                                                                                                                                                property FunctionExpression

                                                                                                                                                                                                                                                                                FunctionExpression: FunctionExpression;

                                                                                                                                                                                                                                                                                  property Identifier

                                                                                                                                                                                                                                                                                  Identifier: Identifier;

                                                                                                                                                                                                                                                                                    property ImportExpression

                                                                                                                                                                                                                                                                                    ImportExpression: ImportExpression;

                                                                                                                                                                                                                                                                                      property Literal

                                                                                                                                                                                                                                                                                      Literal: Literal;

                                                                                                                                                                                                                                                                                        property LogicalExpression

                                                                                                                                                                                                                                                                                        LogicalExpression: LogicalExpression;

                                                                                                                                                                                                                                                                                          property MemberExpression

                                                                                                                                                                                                                                                                                          MemberExpression: MemberExpression;

                                                                                                                                                                                                                                                                                            property MetaProperty

                                                                                                                                                                                                                                                                                            MetaProperty: MetaProperty;

                                                                                                                                                                                                                                                                                              property NewExpression

                                                                                                                                                                                                                                                                                              NewExpression: NewExpression;

                                                                                                                                                                                                                                                                                                property ObjectExpression

                                                                                                                                                                                                                                                                                                ObjectExpression: ObjectExpression;

                                                                                                                                                                                                                                                                                                  property SequenceExpression

                                                                                                                                                                                                                                                                                                  SequenceExpression: SequenceExpression;

                                                                                                                                                                                                                                                                                                    property TaggedTemplateExpression

                                                                                                                                                                                                                                                                                                    TaggedTemplateExpression: TaggedTemplateExpression;

                                                                                                                                                                                                                                                                                                      property TemplateLiteral

                                                                                                                                                                                                                                                                                                      TemplateLiteral: TemplateLiteral;

                                                                                                                                                                                                                                                                                                        property ThisExpression

                                                                                                                                                                                                                                                                                                        ThisExpression: ThisExpression;

                                                                                                                                                                                                                                                                                                          property UnaryExpression

                                                                                                                                                                                                                                                                                                          UnaryExpression: UnaryExpression;

                                                                                                                                                                                                                                                                                                            property UpdateExpression

                                                                                                                                                                                                                                                                                                            UpdateExpression: UpdateExpression;

                                                                                                                                                                                                                                                                                                              property YieldExpression

                                                                                                                                                                                                                                                                                                              YieldExpression: YieldExpression;

                                                                                                                                                                                                                                                                                                                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 NodeMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface NodeMap {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                property AssignmentProperty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                AssignmentProperty: AssignmentProperty;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property CatchClause

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  CatchClause: CatchClause;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property Class

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Class: Class;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property ClassBody

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ClassBody: ClassBody;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property Expression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Expression: Expression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property Function

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Function: Function;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property Identifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Identifier: Identifier;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property Literal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Literal: Literal;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property MethodDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                MethodDefinition: MethodDefinition;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property ModuleDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ModuleDeclaration: ModuleDeclaration;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property ModuleSpecifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ModuleSpecifier: ModuleSpecifier;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property Pattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Pattern: Pattern;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property PrivateIdentifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        PrivateIdentifier: PrivateIdentifier;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property Program

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Program: Program;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property Property

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Property: Property;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property PropertyDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              PropertyDefinition: PropertyDefinition;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property SpreadElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SpreadElement: SpreadElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property Statement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Statement: Statement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property Super

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Super: Super;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property SwitchCase

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SwitchCase: SwitchCase;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property TemplateElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TemplateElement: TemplateElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property VariableDeclarator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          VariableDeclarator: VariableDeclarator;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            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?: 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: Expression[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type: 'SequenceExpression';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface SimpleCallExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface SimpleCallExpression extends BaseCallExpression {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property optional

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    optional: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type: 'CallExpression';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface SimpleLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface SimpleLiteral extends BaseNode, BaseExpression {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property raw

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          raw?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type: 'Literal';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              value: string | boolean | number | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface SourceLocation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface SourceLocation {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property end

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  end: Position;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property source

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    source?: string | null | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property start

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      start: Position;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface SpreadElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface SpreadElement extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property argument

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          argument: Expression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type: 'SpreadElement';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface StaticBlock

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type: 'StaticBlock';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface Super

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface Super extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type: 'Super';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface SwitchCase

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface SwitchCase extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property consequent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        consequent: Statement[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property test

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          test?: Expression | null | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type: 'SwitchCase';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface SwitchStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface SwitchStatement extends BaseStatement {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property cases

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                cases: 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: Expression[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property quasis

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          quasis: 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: 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 = ExpressionMap[keyof ExpressionMap];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            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 = NodeMap[keyof NodeMap];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type Pattern

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Statement

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type UnaryOperator

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type UpdateOperator

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Package Files (1)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                No dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Dev Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                No dev dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                No peer dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Badge

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

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

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