ESTree spec as a table

estree.md

ESTree node types

interface	base	type	body	argument	id	value	test	source	left	right	operator	expression	kind	computed	label	consequent	key	name	generator	object	alternate	init	elements	properties	method	prefix	property	callee	arguments	expressions	static	local	specifiers	declaration	exported	loc	start	end	line	column	regex	sourceType	params	async	directive	discriminant	cases	block	handler	finalizer	param	update	declarations	shorthand	await	delegate	quasis	tag	quasi	tail	superClass	meta	imported	bigint	optional
Node		string																																		SourceLocation | "null"
SourceLocation								string | "null"																													Position	Position
Position																																							number	number
Identifier	Expression, Pattern	"Identifier"																string																		SourceLocation | "null"
Literal	Expression	"Literal"				string | boolean | "null" | number | RegExp | bigint																														SourceLocation | "null"
RegExpLiteral	Literal	"Literal"				string | boolean | "null" | number | RegExp | bigint																														SourceLocation | "null"					{ pattern: string, flags: string }
Program	Node	"Program"	[ Statement | ModuleDeclaration ]																																	SourceLocation | "null"						"script" | "module"
Function	Node	string	FunctionBody		Identifier | "null"														boolean																	SourceLocation | "null"							[ Pattern ]	boolean
Statement	Node	string																																		SourceLocation | "null"
ExpressionStatement	Statement	"ExpressionStatement"										Expression																								SourceLocation | "null"
Directive	ExpressionStatement	"ExpressionStatement"										Literal																								SourceLocation | "null"									string
BlockStatement	Statement	"BlockStatement"	[ Statement ]																																	SourceLocation | "null"
FunctionBody	BlockStatement	"BlockStatement"	[ Directive | Statement ]																																	SourceLocation | "null"
EmptyStatement	Statement	"EmptyStatement"																																		SourceLocation | "null"
DebuggerStatement	Statement	"DebuggerStatement"																																		SourceLocation | "null"
WithStatement	Statement	"WithStatement"	Statement																	Expression																SourceLocation | "null"
ReturnStatement	Statement	"ReturnStatement"		Expression | "null"																																SourceLocation | "null"
LabeledStatement	Statement	"LabeledStatement"	Statement												Identifier																					SourceLocation | "null"
BreakStatement	Statement	"BreakStatement"													Identifier | "null"																					SourceLocation | "null"
ContinueStatement	Statement	"ContinueStatement"													Identifier | "null"																					SourceLocation | "null"
IfStatement	Statement	"IfStatement"					Expression									Statement					Statement | "null"															SourceLocation | "null"
SwitchStatement	Statement	"SwitchStatement"																																		SourceLocation | "null"										Expression	[ SwitchCase ]
SwitchCase	Node	"SwitchCase"					Expression | "null"									[ Statement ]																				SourceLocation | "null"
ThrowStatement	Statement	"ThrowStatement"		Expression																																SourceLocation | "null"
TryStatement	Statement	"TryStatement"																																		SourceLocation | "null"												BlockStatement	CatchClause | "null"	BlockStatement | "null"
CatchClause	Node	"CatchClause"	BlockStatement																																	SourceLocation | "null"															Pattern | "null"
WhileStatement	Statement	"WhileStatement"	Statement				Expression																													SourceLocation | "null"
DoWhileStatement	Statement	"DoWhileStatement"	Statement				Expression																													SourceLocation | "null"
ForStatement	Statement	"ForStatement"	Statement				Expression | "null"															VariableDeclaration | Expression | "null"														SourceLocation | "null"																Expression | "null"
ForInStatement	Statement	"ForInStatement"	Statement						VariableDeclaration | Pattern	Expression																										SourceLocation | "null"
Declaration	Statement	string																																		SourceLocation | "null"
FunctionDeclaration	Function, Declaration	"FunctionDeclaration"	FunctionBody		Identifier														boolean																	SourceLocation | "null"							[ Pattern ]	boolean
VariableDeclaration	Declaration	"VariableDeclaration"											"var" | "let" | "const"																							SourceLocation | "null"																	[ VariableDeclarator ]
VariableDeclarator	Node	"VariableDeclarator"			Pattern																	Expression | "null"														SourceLocation | "null"
Expression	Node	string																																		SourceLocation | "null"
ThisExpression	Expression	"ThisExpression"																																		SourceLocation | "null"
ArrayExpression	Expression	"ArrayExpression"																					[ Expression | SpreadElement | "null" ]													SourceLocation | "null"
ObjectExpression	Expression	"ObjectExpression"																						[ Property | SpreadElement ]												SourceLocation | "null"
Property	Node	"Property"				Expression							"init" | "get" | "set"	boolean			Expression								boolean											SourceLocation | "null"																		boolean
FunctionExpression	Function, Expression	"FunctionExpression"	FunctionBody		Identifier | "null"														boolean																	SourceLocation | "null"							[ Pattern ]	boolean
UnaryExpression	Expression	"UnaryExpression"		Expression							UnaryOperator															boolean										SourceLocation | "null"
UpdateExpression	Expression	"UpdateExpression"		Expression							UpdateOperator															boolean										SourceLocation | "null"
BinaryExpression	Expression	"BinaryExpression"							Expression | PrivateIdentifier	Expression	BinaryOperator																									SourceLocation | "null"
AssignmentExpression	Expression	"AssignmentExpression"							Pattern	Expression	AssignmentOperator																									SourceLocation | "null"
LogicalExpression	Expression	"LogicalExpression"							Expression	Expression	LogicalOperator																									SourceLocation | "null"
MemberExpression	Expression, Pattern, ChainElement	"MemberExpression"												boolean						Expression | Super							Expression | PrivateIdentifier									SourceLocation | "null"																													boolean
ConditionalExpression	Expression	"ConditionalExpression"					Expression									Expression					Expression															SourceLocation | "null"
CallExpression	Expression, ChainElement	"CallExpression"																										Expression | Super	[ Expression | SpreadElement ]							SourceLocation | "null"																													boolean
NewExpression	Expression	"NewExpression"																										Expression	[ Expression | SpreadElement ]							SourceLocation | "null"
SequenceExpression	Expression	"SequenceExpression"																												[ Expression ]						SourceLocation | "null"
Pattern	Node	string																																		SourceLocation | "null"
ForOfStatement	ForInStatement	"ForOfStatement"	Statement						VariableDeclaration | Pattern	Expression																										SourceLocation | "null"																			boolean
Super	Node	"Super"																																		SourceLocation | "null"
SpreadElement	Node	"SpreadElement"		Expression																																SourceLocation | "null"
ArrowFunctionExpression	Function, Expression	"ArrowFunctionExpression"	FunctionBody | Expression		Identifier | "null"							boolean							"false"																	SourceLocation | "null"							[ Pattern ]	boolean
YieldExpression	Expression	"YieldExpression"		Expression | "null"																																SourceLocation | "null"																				boolean
TemplateLiteral	Expression	"TemplateLiteral"																												[ Expression ]						SourceLocation | "null"																					[ TemplateElement ]
TaggedTemplateExpression	Expression	"TaggedTemplateExpression"																																		SourceLocation | "null"																						Expression	TemplateLiteral
TemplateElement	Node	"TemplateElement"				{ cooked: string | "null", raw: string }																														SourceLocation | "null"																								boolean
AssignmentProperty	Property	"Property"				Pattern							"init"	boolean			Expression								"false"											SourceLocation | "null"																		boolean
ObjectPattern	Pattern	"ObjectPattern"																						[ AssignmentProperty | RestElement ]												SourceLocation | "null"
ArrayPattern	Pattern	"ArrayPattern"																					[ Pattern | "null" ]													SourceLocation | "null"
RestElement	Pattern	"RestElement"		Pattern																																SourceLocation | "null"
AssignmentPattern	Pattern	"AssignmentPattern"							Pattern	Expression																										SourceLocation | "null"
Class	Node	string	ClassBody		Identifier | "null"																															SourceLocation | "null"																									Expression | "null"
ClassBody	Node	"ClassBody"	[ MethodDefinition | PropertyDefinition | StaticBlock ]																																	SourceLocation | "null"
MethodDefinition	Node	"MethodDefinition"				FunctionExpression							"constructor" | "method" | "get" | "set"	boolean			Expression | PrivateIdentifier														boolean					SourceLocation | "null"
ClassDeclaration	Class, Declaration	"ClassDeclaration"	ClassBody		Identifier																															SourceLocation | "null"																									Expression | "null"
ClassExpression	Class, Expression	"ClassExpression"	ClassBody		Identifier | "null"																															SourceLocation | "null"																									Expression | "null"
MetaProperty	Expression	"MetaProperty"																									Identifier									SourceLocation | "null"																										Identifier
ModuleDeclaration	Node	string																																		SourceLocation | "null"
ModuleSpecifier	Node	string																														Identifier				SourceLocation | "null"
ImportDeclaration	ModuleDeclaration	"ImportDeclaration"						Literal																									[ ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier ]			SourceLocation | "null"
ImportSpecifier	ModuleSpecifier	"ImportSpecifier"																														Identifier				SourceLocation | "null"																											Identifier | Literal
ImportDefaultSpecifier	ModuleSpecifier	"ImportDefaultSpecifier"																														Identifier				SourceLocation | "null"
ImportNamespaceSpecifier	ModuleSpecifier	"ImportNamespaceSpecifier"																														Identifier				SourceLocation | "null"
ExportNamedDeclaration	ModuleDeclaration	"ExportNamedDeclaration"						Literal | "null"																									[ ExportSpecifier ]	Declaration | "null"		SourceLocation | "null"
ExportSpecifier	ModuleSpecifier	"ExportSpecifier"																														Identifier | Literal			Identifier | Literal	SourceLocation | "null"
AnonymousDefaultExportedFunctionDeclaration	Function	"FunctionDeclaration"	FunctionBody		"null"														boolean																	SourceLocation | "null"							[ Pattern ]	boolean
AnonymousDefaultExportedClassDeclaration	Class	"ClassDeclaration"	ClassBody		"null"																															SourceLocation | "null"																									Expression | "null"
ExportDefaultDeclaration	ModuleDeclaration	"ExportDefaultDeclaration"																																AnonymousDefaultExportedFunctionDeclaration | FunctionDeclaration | AnonymousDefaultExportedClassDeclaration | ClassDeclaration | Expression		SourceLocation | "null"
ExportAllDeclaration	ModuleDeclaration	"ExportAllDeclaration"						Literal																											Identifier | Literal | "null"	SourceLocation | "null"
AwaitExpression	Expression	"AwaitExpression"		Expression																																SourceLocation | "null"
BigIntLiteral	Literal	"Literal"				string | boolean | "null" | number | RegExp | bigint																														SourceLocation | "null"																												string
ChainExpression	Expression	"ChainExpression"										ChainElement																								SourceLocation | "null"
ChainElement	Node	string																																		SourceLocation | "null"																													boolean
ImportExpression	Expression	"ImportExpression"						Expression																												SourceLocation | "null"
PropertyDefinition	Node	"PropertyDefinition"				Expression | "null"								boolean			Expression | PrivateIdentifier														boolean					SourceLocation | "null"
PrivateIdentifier	Node	"PrivateIdentifier"																string																		SourceLocation | "null"
StaticBlock	BlockStatement	"StaticBlock"	[ Statement ]																																	SourceLocation | "null"

Node

ES5:

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

SourceLocation

ES5:

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

Position

ES5:

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

Identifier

ES5:

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

Literal

ES5:

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

ES2020:

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

RegExpLiteral

ES5:

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

Program

ES5:

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

ES2015:

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

Function

ES5:

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

ES2015:

extend interface Function {
    generator: boolean;
}

ES2017:

extend interface Function {
    async: boolean;
}

Statement

ES5:

interface Statement <: Node { }

ExpressionStatement

ES5:

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

Directive

ES5:

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

BlockStatement

ES5:

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

FunctionBody

ES5:

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

EmptyStatement

ES5:

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

DebuggerStatement

ES5:

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

WithStatement

ES5:

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

ReturnStatement

ES5:

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

LabeledStatement

ES5:

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

BreakStatement

ES5:

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

ContinueStatement

ES5:

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

IfStatement

ES5:

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

SwitchStatement

ES5:

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

SwitchCase

ES5:

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

ThrowStatement

ES5:

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

TryStatement

ES5:

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

CatchClause

ES5:

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

ES2019:

extend interface CatchClause {
    param: Pattern | null;
}

WhileStatement

ES5:

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

DoWhileStatement

ES5:

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

ForStatement

ES5:

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

ForInStatement

ES5:

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

Declaration

ES5:

interface Declaration <: Statement { }

FunctionDeclaration

ES5:

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

VariableDeclaration

ES5:

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

ES2015:

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

VariableDeclarator

ES5:

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

Expression

ES5:

interface Expression <: Node { }

ThisExpression

ES5:

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

ArrayExpression

ES5:

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

ES2015:

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

ObjectExpression

ES5:

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

ES2018:

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

Property

ES5:

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

ES2015:

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

FunctionExpression

ES5:

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

UnaryExpression

ES5:

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

UnaryOperator

ES5:

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

UpdateExpression

ES5:

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

UpdateOperator

ES5:

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

BinaryExpression

ES5:

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

ES2022:

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

BinaryOperator

ES5:

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

ES2016:

extend enum BinaryOperator {
    "**"
}

AssignmentExpression

ES5:

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

ES2015:

extend interface AssignmentExpression {
    left: Pattern;
}

AssignmentOperator

ES5:

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

ES2016:

extend enum AssignmentOperator {
    "**="
}

ES2021:

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

LogicalExpression

ES5:

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

LogicalOperator

ES5:

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

ES2020:

extend enum LogicalOperator {
    "||" | "&&" | "??"
}

MemberExpression

ES5:

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

ES2015:

extend interface MemberExpression {
    object: Expression | Super;
}

ES2020:

extend interface MemberExpression <: ChainElement {}

ES2022:

extend interface MemberExpression {
    property: Expression | PrivateIdentifier;
}

ConditionalExpression

ES5:

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

CallExpression

ES5:

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

ES2015:

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

ES2020:

extend interface CallExpression <: ChainElement {}

NewExpression

ES5:

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

ES2015:

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

SequenceExpression

ES5:

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

Pattern

ES5:

interface Pattern <: Node { }

ForOfStatement

ES2015:

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

ES2018:

extend interface ForOfStatement {
  await: boolean;
}

Super

ES2015:

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

SpreadElement

ES2015:

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

ArrowFunctionExpression

ES2015:

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

YieldExpression

ES2015:

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

TemplateLiteral

ES2015:

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

TaggedTemplateExpression

ES2015:

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

TemplateElement

ES2015:

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

ES2018:

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

AssignmentProperty

ES2015:

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

ObjectPattern

ES2015:

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

ES2018:

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

ArrayPattern

ES2015:

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

RestElement

ES2015:

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

AssignmentPattern

ES2015:

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

Class

ES2015:

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

ClassBody

ES2015:

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

ES2022:

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

MethodDefinition

ES2015:

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

ES2022:

extend interface MethodDefinition {
    key: Expression | PrivateIdentifier;
}

ClassDeclaration

ES2015:

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

ClassExpression

ES2015:

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

MetaProperty

ES2015:

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

ModuleDeclaration

ES2015:

interface ModuleDeclaration <: Node { }

ModuleSpecifier

ES2015:

interface ModuleSpecifier <: Node {
    local: Identifier;
}

ImportDeclaration

ES2015:

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

ImportSpecifier

ES2015:

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

ES2022:

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

ImportDefaultSpecifier

ES2015:

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

ImportNamespaceSpecifier

ES2015:

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

ExportNamedDeclaration

ES2015:

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

ExportSpecifier

ES2015:

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

ES2022:

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

AnonymousDefaultExportedFunctionDeclaration

ES2015:

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

AnonymousDefaultExportedClassDeclaration

ES2015:

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

ExportDefaultDeclaration

ES2015:

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

ExportAllDeclaration

ES2015:

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

ES2020:

extend interface ExportAllDeclaration {
  exported: Identifier | null;
}

ES2022:

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

AwaitExpression

ES2017:

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

BigIntLiteral

ES2020:

interface BigIntLiteral <: Literal {
  bigint: string;
}

ChainExpression

ES2020:

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

ChainElement

ES2020:

interface ChainElement <: Node {
  optional: boolean;
}

ImportExpression

ES2020:

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

PropertyDefinition

ES2022:

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

PrivateIdentifier

ES2022:

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

StaticBlock

ES2022:

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