@types/estree

elements: Array<Expression | SpreadElement | null>;

type: 'ArrayExpression';

elements: Array<Pattern | null>;

type: 'ArrayPattern';

body: BlockStatement | Expression;

expression: boolean;

type: 'ArrowFunctionExpression';

left: Pattern | MemberExpression;

operator: AssignmentOperator;

right: Expression;

type: 'AssignmentExpression';

left: Pattern;

right: Expression;

type: 'AssignmentPattern';

kind: 'init';

method: boolean;

value: Pattern;

argument: Expression;

type: 'AwaitExpression';

arguments: Array<Expression | SpreadElement>;

callee: Expression | Super;

body: ClassBody;

superClass?: Expression | null | undefined;

body: Statement;

left: VariableDeclaration | Pattern;

right: Expression;

async?: boolean | undefined;

body: BlockStatement | Expression;

generator?: boolean | undefined;

params: Array<Pattern>;

local: Identifier;

leadingComments?: Array<Comment> | undefined;

trailingComments?: Array<Comment> | undefined;

loc?: SourceLocation | null | undefined;

range?: [number, number] | undefined;

type: string;

bigint: string;

raw?: string | undefined;

type: 'Literal';

value?: bigint | null | undefined;

left: Expression;

operator: BinaryOperator;

right: Expression;

type: 'BinaryExpression';

body: Array<Statement>;

innerComments?: Array<Comment> | undefined;

type: 'BlockStatement';

label?: Identifier | null | undefined;

type: 'BreakStatement';

body: BlockStatement;

param: Pattern | null;

type: 'CatchClause';

expression: ChainElement;

type: 'ChainExpression';

body: Array<MethodDefinition | PropertyDefinition | StaticBlock>;

type: 'ClassBody';

id: Identifier | null;

type: 'ClassDeclaration';

id?: Identifier | null | undefined;

type: 'ClassExpression';

type: 'Line' | 'Block';

value: string;

alternate: Expression;

consequent: Expression;

test: Expression;

type: 'ConditionalExpression';

label?: Identifier | null | undefined;

type: 'ContinueStatement';

type: 'DebuggerStatement';

directive: string;

expression: Literal;

type: 'ExpressionStatement';

body: Statement;

test: Expression;

type: 'DoWhileStatement';

type: 'EmptyStatement';

exported: Identifier | null;

source: Literal;

type: 'ExportAllDeclaration';

declaration: Declaration | Expression;

type: 'ExportDefaultDeclaration';

declaration?: Declaration | null | undefined;

source?: Literal | null | undefined;

specifiers: Array<ExportSpecifier>;

type: 'ExportNamedDeclaration';

exported: Identifier;

type: 'ExportSpecifier';

expression: Expression;

type: 'ExpressionStatement';

type: 'ForInStatement';

await: boolean;

type: 'ForOfStatement';

body: Statement;

init?: VariableDeclaration | Expression | null | undefined;

test?: Expression | null | undefined;

type: 'ForStatement';

update?: Expression | null | undefined;

body: BlockStatement;

id: Identifier | null;

type: 'FunctionDeclaration';

body: BlockStatement;

id?: Identifier | null | undefined;

type: 'FunctionExpression';

name: string;

type: 'Identifier';

alternate?: Statement | null | undefined;

consequent: Statement;

test: Expression;

type: 'IfStatement';

source: Literal;

specifiers: Array<
    ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier
>;

type: 'ImportDeclaration';

type: 'ImportDefaultSpecifier';

source: Expression;

type: 'ImportExpression';

type: 'ImportNamespaceSpecifier';

imported: Identifier;

type: 'ImportSpecifier';

body: Statement;

label: Identifier;

type: 'LabeledStatement';

left: Expression;

operator: LogicalOperator;

right: Expression;

type: 'LogicalExpression';

computed: boolean;

object: Expression | Super;

optional: boolean;

property: Expression | PrivateIdentifier;

type: 'MemberExpression';

meta: Identifier;

property: Identifier;

type: 'MetaProperty';

computed: boolean;

key: Expression | PrivateIdentifier;

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

static: boolean;

type: 'MethodDefinition';

value: FunctionExpression;

type: 'NewExpression';

properties: Array<Property | SpreadElement>;

type: 'ObjectExpression';

properties: Array<AssignmentProperty | RestElement>;

type: 'ObjectPattern';

column: number;

line: number;

name: string;

type: 'PrivateIdentifier';

body: Array<Directive | Statement | ModuleDeclaration>;

comments?: Array<Comment> | undefined;

sourceType: 'script' | 'module';

type: 'Program';

computed: boolean;

key: Expression | PrivateIdentifier;

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

method: boolean;

shorthand: boolean;

type: 'Property';

value: Expression | Pattern;

computed: boolean;

key: Expression | PrivateIdentifier;

static: boolean;

type: 'PropertyDefinition';

value?: Expression | null | undefined;

raw?: string | undefined;

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

type: 'Literal';

value?: RegExp | null | undefined;

argument: Pattern;

type: 'RestElement';

argument?: Expression | null | undefined;

type: 'ReturnStatement';

expressions: Array<Expression>;

type: 'SequenceExpression';

optional: boolean;

type: 'CallExpression';

raw?: string | undefined;

type: 'Literal';

value: string | boolean | number | null;

end: Position;

source?: string | null | undefined;

start: Position;

argument: Expression;

type: 'SpreadElement';

type: 'StaticBlock';

type: 'Super';

consequent: Array<Statement>;

test?: Expression | null | undefined;

type: 'SwitchCase';

cases: Array<SwitchCase>;

discriminant: Expression;

type: 'SwitchStatement';

quasi: TemplateLiteral;

tag: Expression;

type: 'TaggedTemplateExpression';

tail: boolean;

type: 'TemplateElement';

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

expressions: Array<Expression>;

quasis: Array<TemplateElement>;

type: 'TemplateLiteral';

type: 'ThisExpression';

argument: Expression;

type: 'ThrowStatement';

block: BlockStatement;

finalizer?: BlockStatement | null | undefined;

handler?: CatchClause | null | undefined;

type: 'TryStatement';

argument: Expression;

operator: UnaryOperator;

prefix: true;

type: 'UnaryExpression';

argument: Expression;

operator: UpdateOperator;

prefix: boolean;

type: 'UpdateExpression';

declarations: Array<VariableDeclarator>;

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

type: 'VariableDeclaration';

id: Pattern;

init?: Expression | null | undefined;

type: 'VariableDeclarator';

body: Statement;

test: Expression;

type: 'WhileStatement';

body: Statement;

object: Expression;

type: 'WithStatement';

argument?: Expression | null | undefined;