webpack 5.83.1 → 5.84.0

package/lib/javascript/JavascriptParser.js

@@ -16,43 +16,77 @@ const memoize = require("../util/memoize");
 const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
 
 /** @typedef {import("acorn").Options} AcornOptions */
-/** @typedef {import("estree").ArrayExpression} ArrayExpressionNode */
-/** @typedef {import("estree").BinaryExpression} BinaryExpressionNode */
-/** @typedef {import("estree").BlockStatement} BlockStatementNode */
-/** @typedef {import("estree").SequenceExpression} SequenceExpressionNode */
-/** @typedef {import("estree").CallExpression} CallExpressionNode */
-/** @typedef {import("estree").ClassDeclaration} ClassDeclarationNode */
-/** @typedef {import("estree").ClassExpression} ClassExpressionNode */
-/** @typedef {import("estree").Comment} CommentNode */
-/** @typedef {import("estree").ConditionalExpression} ConditionalExpressionNode */
-/** @typedef {import("estree").Declaration} DeclarationNode */
-/** @typedef {import("estree").PrivateIdentifier} PrivateIdentifierNode */
-/** @typedef {import("estree").PropertyDefinition} PropertyDefinitionNode */
-/** @typedef {import("estree").Expression} ExpressionNode */
-/** @typedef {import("estree").Identifier} IdentifierNode */
-/** @typedef {import("estree").IfStatement} IfStatementNode */
-/** @typedef {import("estree").LabeledStatement} LabeledStatementNode */
-/** @typedef {import("estree").Literal} LiteralNode */
-/** @typedef {import("estree").LogicalExpression} LogicalExpressionNode */
-/** @typedef {import("estree").ChainExpression} ChainExpressionNode */
-/** @typedef {import("estree").MemberExpression} MemberExpressionNode */
-/** @typedef {import("estree").MetaProperty} MetaPropertyNode */
-/** @typedef {import("estree").MethodDefinition} MethodDefinitionNode */
-/** @typedef {import("estree").ModuleDeclaration} ModuleDeclarationNode */
-/** @typedef {import("estree").NewExpression} NewExpressionNode */
+/** @typedef {import("estree").AssignmentExpression} AssignmentExpression */
+/** @typedef {import("estree").BinaryExpression} BinaryExpression */
+/** @typedef {import("estree").BlockStatement} BlockStatement */
+/** @typedef {import("estree").SequenceExpression} SequenceExpression */
+/** @typedef {import("estree").CallExpression} CallExpression */
+/** @typedef {import("estree").BaseCallExpression} BaseCallExpression */
+/** @typedef {import("estree").StaticBlock} StaticBlock */
+/** @typedef {import("estree").ImportExpression} ImportExpression */
+/** @typedef {import("estree").ClassDeclaration} ClassDeclaration */
+/** @typedef {import("estree").ForStatement} ForStatement */
+/** @typedef {import("estree").SwitchStatement} SwitchStatement */
+/** @typedef {import("estree").ExportNamedDeclaration} ExportNamedDeclaration */
+/** @typedef {import("estree").ClassExpression} ClassExpression */
+/** @typedef {import("estree").Comment} Comment */
+/** @typedef {import("estree").ConditionalExpression} ConditionalExpression */
+/** @typedef {import("estree").Declaration} Declaration */
+/** @typedef {import("estree").PrivateIdentifier} PrivateIdentifier */
+/** @typedef {import("estree").PropertyDefinition} PropertyDefinition */
+/** @typedef {import("estree").Expression} Expression */
+/** @typedef {import("estree").Identifier} Identifier */
+/** @typedef {import("estree").VariableDeclaration} VariableDeclaration */
+/** @typedef {import("estree").IfStatement} IfStatement */
+/** @typedef {import("estree").LabeledStatement} LabeledStatement */
+/** @typedef {import("estree").Literal} Literal */
+/** @typedef {import("estree").LogicalExpression} LogicalExpression */
+/** @typedef {import("estree").ChainExpression} ChainExpression */
+/** @typedef {import("estree").MemberExpression} MemberExpression */
+/** @typedef {import("estree").YieldExpression} YieldExpression */
+/** @typedef {import("estree").MetaProperty} MetaProperty */
+/** @typedef {import("estree").Property} Property */
+/** @typedef {import("estree").AssignmentPattern} AssignmentPattern */
+/** @typedef {import("estree").Pattern} Pattern */
+/** @typedef {import("estree").UpdateExpression} UpdateExpression */
+/** @typedef {import("estree").ObjectExpression} ObjectExpression */
+/** @typedef {import("estree").UnaryExpression} UnaryExpression */
+/** @typedef {import("estree").ArrayExpression} ArrayExpression */
+/** @typedef {import("estree").ArrayPattern} ArrayPattern */
+/** @typedef {import("estree").AwaitExpression} AwaitExpression */
+/** @typedef {import("estree").ThisExpression} ThisExpression */
+/** @typedef {import("estree").RestElement} RestElement */
+/** @typedef {import("estree").ObjectPattern} ObjectPattern */
+/** @typedef {import("estree").SwitchCase} SwitchCase */
+/** @typedef {import("estree").CatchClause} CatchClause */
+/** @typedef {import("estree").VariableDeclarator} VariableDeclarator */
+/** @typedef {import("estree").ForInStatement} ForInStatement */
+/** @typedef {import("estree").ForOfStatement} ForOfStatement */
+/** @typedef {import("estree").ReturnStatement} ReturnStatement */
+/** @typedef {import("estree").WithStatement} WithStatement */
+/** @typedef {import("estree").ThrowStatement} ThrowStatement */
+/** @typedef {import("estree").MethodDefinition} MethodDefinition */
+/** @typedef {import("estree").ModuleDeclaration} ModuleDeclaration */
+/** @typedef {import("estree").NewExpression} NewExpression */
+/** @typedef {import("estree").SpreadElement} SpreadElement */
+/** @typedef {import("estree").FunctionExpression} FunctionExpression */
+/** @typedef {import("estree").WhileStatement} WhileStatement */
+/** @typedef {import("estree").ArrowFunctionExpression} ArrowFunctionExpression */
+/** @typedef {import("estree").ExpressionStatement} ExpressionStatement */
+/** @typedef {import("estree").FunctionDeclaration} FunctionDeclaration */
+/** @typedef {import("estree").DoWhileStatement} DoWhileStatement */
+/** @typedef {import("estree").TryStatement} TryStatement */
 /** @typedef {import("estree").Node} AnyNode */
-/** @typedef {import("estree").Program} ProgramNode */
-/** @typedef {import("estree").Statement} StatementNode */
-/** @typedef {import("estree").ImportDeclaration} ImportDeclarationNode */
-/** @typedef {import("estree").ExportNamedDeclaration} ExportNamedDeclarationNode */
-/** @typedef {import("estree").ExportDefaultDeclaration} ExportDefaultDeclarationNode */
-/** @typedef {import("estree").ExportAllDeclaration} ExportAllDeclarationNode */
-/** @typedef {import("estree").Super} SuperNode */
-/** @typedef {import("estree").TaggedTemplateExpression} TaggedTemplateExpressionNode */
-/** @typedef {import("estree").TemplateLiteral} TemplateLiteralNode */
-/** @typedef {import("estree").ThisExpression} ThisExpressionNode */
-/** @typedef {import("estree").UnaryExpression} UnaryExpressionNode */
-/** @typedef {import("estree").VariableDeclarator} VariableDeclaratorNode */
+/** @typedef {import("estree").Program} Program */
+/** @typedef {import("estree").Directive} Directive */
+/** @typedef {import("estree").Statement} Statement */
+/** @typedef {import("estree").ImportDeclaration} ImportDeclaration */
+/** @typedef {import("estree").ExportDefaultDeclaration} ExportDefaultDeclaration */
+/** @typedef {import("estree").ExportAllDeclaration} ExportAllDeclaration */
+/** @typedef {import("estree").Super} Super */
+/** @typedef {import("estree").TaggedTemplateExpression} TaggedTemplateExpression */
+/** @typedef {import("estree").TemplateLiteral} TemplateLiteral */
+/** @typedef {Record<string, any>} Assertions */
 /** @template T @typedef {import("tapable").AsArray<T>} AsArray<T> */
 /** @typedef {import("../Parser").ParserState} ParserState */
 /** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
@@ -82,7 +116,7 @@ class VariableInfo {
 }
 
 /** @typedef {string | ScopeInfo | VariableInfo} ExportedVariableInfo */
-/** @typedef {LiteralNode | string | null | undefined} ImportSource */
+/** @typedef {Literal | string | null | undefined} ImportSource */
 /** @typedef {Omit<AcornOptions, "sourceType" | "ecmaVersion"> & { sourceType: "module" | "script" | "auto", ecmaVersion?: AcornOptions["ecmaVersion"] }} ParseOptions */
 
 /**
@@ -96,12 +130,14 @@ class VariableInfo {
  * @typedef {Object} ScopeInfo
  * @property {StackedMap<string, VariableInfo | ScopeInfo>} definitions
  * @property {boolean | "arrow"} topLevelScope
- * @property {boolean} inShorthand
+ * @property {boolean | string} inShorthand
  * @property {boolean} isStrict
  * @property {boolean} isAsmJs
  * @property {boolean} inTry
  */
 
+/** @typedef {[number, number]} Range */
+
 /**
  * Helper function for joining two ranges into a single range. This is useful
  * when working with AST nodes, as it allows you to combine the ranges of child nodes
@@ -157,7 +193,7 @@ const objectAndMembersToName = (object, membersReversed) => {
  * [MetaProperties](https://github.com/estree/estree/blob/master/es2015.md#metaproperty) which is
  * specifically for handling the `new.target` meta property.
  *
- * @param {ExpressionNode | SuperNode} expression expression
+ * @param {Expression | Super} expression expression
  * @returns {string | "this" | undefined} name or variable info
  */
 const getRootName = expression => {
@@ -199,81 +235,81 @@ class JavascriptParser extends Parser {
 	constructor(sourceType = "auto") {
 		super();
 		this.hooks = Object.freeze({
-			/** @type {HookMap<SyncBailHook<[UnaryExpressionNode], BasicEvaluatedExpression | undefined | null>>} */
+			/** @type {HookMap<SyncBailHook<[UnaryExpression], BasicEvaluatedExpression | undefined | null>>} */
 			evaluateTypeof: new HookMap(() => new SyncBailHook(["expression"])),
-			/** @type {HookMap<SyncBailHook<[ExpressionNode], BasicEvaluatedExpression | undefined | null>>} */
+			/** @type {HookMap<SyncBailHook<[Expression], BasicEvaluatedExpression | undefined | null>>} */
 			evaluate: new HookMap(() => new SyncBailHook(["expression"])),
-			/** @type {HookMap<SyncBailHook<[IdentifierNode | ThisExpressionNode | MemberExpressionNode | MetaPropertyNode], BasicEvaluatedExpression | undefined | null>>} */
+			/** @type {HookMap<SyncBailHook<[Identifier | ThisExpression | MemberExpression | MetaProperty], BasicEvaluatedExpression | undefined | null>>} */
 			evaluateIdentifier: new HookMap(() => new SyncBailHook(["expression"])),
-			/** @type {HookMap<SyncBailHook<[IdentifierNode | ThisExpressionNode | MemberExpressionNode], BasicEvaluatedExpression | undefined | null>>} */
+			/** @type {HookMap<SyncBailHook<[Identifier | ThisExpression | MemberExpression], BasicEvaluatedExpression | undefined | null>>} */
 			evaluateDefinedIdentifier: new HookMap(
 				() => new SyncBailHook(["expression"])
 			),
-			/** @type {HookMap<SyncBailHook<[NewExpressionNode], BasicEvaluatedExpression | undefined | null>>} */
+			/** @type {HookMap<SyncBailHook<[NewExpression], BasicEvaluatedExpression | undefined | null>>} */
 			evaluateNewExpression: new HookMap(
 				() => new SyncBailHook(["expression"])
 			),
-			/** @type {HookMap<SyncBailHook<[CallExpressionNode], BasicEvaluatedExpression | undefined | null>>} */
+			/** @type {HookMap<SyncBailHook<[CallExpression], BasicEvaluatedExpression | undefined | null>>} */
 			evaluateCallExpression: new HookMap(
 				() => new SyncBailHook(["expression"])
 			),
-			/** @type {HookMap<SyncBailHook<[CallExpressionNode, BasicEvaluatedExpression | undefined], BasicEvaluatedExpression | undefined | null>>} */
+			/** @type {HookMap<SyncBailHook<[CallExpression, BasicEvaluatedExpression | undefined], BasicEvaluatedExpression | undefined | null>>} */
 			evaluateCallExpressionMember: new HookMap(
 				() => new SyncBailHook(["expression", "param"])
 			),
-			/** @type {HookMap<SyncBailHook<[ExpressionNode | DeclarationNode | PrivateIdentifierNode, number], boolean | void>>} */
+			/** @type {HookMap<SyncBailHook<[Expression | Declaration | PrivateIdentifier, number], boolean | void>>} */
 			isPure: new HookMap(
 				() => new SyncBailHook(["expression", "commentsStartPosition"])
 			),
-			/** @type {SyncBailHook<[StatementNode | ModuleDeclarationNode], boolean | void>} */
+			/** @type {SyncBailHook<[Statement | ModuleDeclaration], boolean | void>} */
 			preStatement: new SyncBailHook(["statement"]),
 
-			/** @type {SyncBailHook<[StatementNode | ModuleDeclarationNode], boolean | void>} */
+			/** @type {SyncBailHook<[Statement | ModuleDeclaration], boolean | void>} */
 			blockPreStatement: new SyncBailHook(["declaration"]),
-			/** @type {SyncBailHook<[StatementNode | ModuleDeclarationNode], boolean | void>} */
+			/** @type {SyncBailHook<[Statement | ModuleDeclaration], boolean | void>} */
 			statement: new SyncBailHook(["statement"]),
-			/** @type {SyncBailHook<[IfStatementNode], boolean | void>} */
+			/** @type {SyncBailHook<[IfStatement], boolean | void>} */
 			statementIf: new SyncBailHook(["statement"]),
-			/** @type {SyncBailHook<[ExpressionNode, ClassExpressionNode | ClassDeclarationNode], boolean | void>} */
+			/** @type {SyncBailHook<[Expression, ClassExpression | ClassDeclaration], boolean | void>} */
 			classExtendsExpression: new SyncBailHook([
 				"expression",
 				"classDefinition"
 			]),
-			/** @type {SyncBailHook<[MethodDefinitionNode | PropertyDefinitionNode, ClassExpressionNode | ClassDeclarationNode], boolean | void>} */
+			/** @type {SyncBailHook<[MethodDefinition | PropertyDefinition | StaticBlock, ClassExpression | ClassDeclaration], boolean | void>} */
 			classBodyElement: new SyncBailHook(["element", "classDefinition"]),
-			/** @type {SyncBailHook<[ExpressionNode, MethodDefinitionNode | PropertyDefinitionNode, ClassExpressionNode | ClassDeclarationNode], boolean | void>} */
+			/** @type {SyncBailHook<[Expression, MethodDefinition | PropertyDefinition, ClassExpression | ClassDeclaration], boolean | void>} */
 			classBodyValue: new SyncBailHook([
 				"expression",
 				"element",
 				"classDefinition"
 			]),
-			/** @type {HookMap<SyncBailHook<[LabeledStatementNode], boolean | void>>} */
+			/** @type {HookMap<SyncBailHook<[LabeledStatement], boolean | void>>} */
 			label: new HookMap(() => new SyncBailHook(["statement"])),
-			/** @type {SyncBailHook<[ImportDeclarationNode, ImportSource], boolean | void>} */
+			/** @type {SyncBailHook<[ImportDeclaration, ImportSource], boolean | void>} */
 			import: new SyncBailHook(["statement", "source"]),
-			/** @type {SyncBailHook<[ImportDeclarationNode, ImportSource, string, string], boolean | void>} */
+			/** @type {SyncBailHook<[ImportDeclaration, ImportSource, string, string], boolean | void>} */
 			importSpecifier: new SyncBailHook([
 				"statement",
 				"source",
 				"exportName",
 				"identifierName"
 			]),
-			/** @type {SyncBailHook<[ExportNamedDeclarationNode | ExportAllDeclarationNode], boolean | void>} */
+			/** @type {SyncBailHook<[ExportNamedDeclaration | ExportAllDeclaration], boolean | void>} */
 			export: new SyncBailHook(["statement"]),
-			/** @type {SyncBailHook<[ExportNamedDeclarationNode | ExportAllDeclarationNode, ImportSource], boolean | void>} */
+			/** @type {SyncBailHook<[ExportNamedDeclaration | ExportAllDeclaration, ImportSource], boolean | void>} */
 			exportImport: new SyncBailHook(["statement", "source"]),
-			/** @type {SyncBailHook<[ExportNamedDeclarationNode | ExportAllDeclarationNode, DeclarationNode], boolean | void>} */
+			/** @type {SyncBailHook<[ExportNamedDeclaration | ExportAllDeclaration, Declaration], boolean | void>} */
 			exportDeclaration: new SyncBailHook(["statement", "declaration"]),
-			/** @type {SyncBailHook<[ExportDefaultDeclarationNode, DeclarationNode], boolean | void>} */
+			/** @type {SyncBailHook<[ExportDefaultDeclaration, Declaration], boolean | void>} */
 			exportExpression: new SyncBailHook(["statement", "declaration"]),
-			/** @type {SyncBailHook<[ExportNamedDeclarationNode | ExportAllDeclarationNode, string, string, number | undefined], boolean | void>} */
+			/** @type {SyncBailHook<[ExportNamedDeclaration | ExportAllDeclaration, string, string, number | undefined], boolean | void>} */
 			exportSpecifier: new SyncBailHook([
 				"statement",
 				"identifierName",
 				"exportName",
 				"index"
 			]),
-			/** @type {SyncBailHook<[ExportNamedDeclarationNode | ExportAllDeclarationNode, ImportSource, string, string, number | undefined], boolean | void>} */
+			/** @type {SyncBailHook<[ExportNamedDeclaration | ExportAllDeclaration, ImportSource, string, string, number | undefined], boolean | void>} */
 			exportImportSpecifier: new SyncBailHook([
 				"statement",
 				"source",
@@ -281,45 +317,45 @@ class JavascriptParser extends Parser {
 				"exportName",
 				"index"
 			]),
-			/** @type {SyncBailHook<[VariableDeclaratorNode, StatementNode], boolean | void>} */
+			/** @type {SyncBailHook<[VariableDeclarator, Statement], boolean | void>} */
 			preDeclarator: new SyncBailHook(["declarator", "statement"]),
-			/** @type {SyncBailHook<[VariableDeclaratorNode, StatementNode], boolean | void>} */
+			/** @type {SyncBailHook<[VariableDeclarator, Statement], boolean | void>} */
 			declarator: new SyncBailHook(["declarator", "statement"]),
-			/** @type {HookMap<SyncBailHook<[DeclarationNode], boolean | void>>} */
+			/** @type {HookMap<SyncBailHook<[Declaration], boolean | void>>} */
 			varDeclaration: new HookMap(() => new SyncBailHook(["declaration"])),
-			/** @type {HookMap<SyncBailHook<[DeclarationNode], boolean | void>>} */
+			/** @type {HookMap<SyncBailHook<[Declaration], boolean | void>>} */
 			varDeclarationLet: new HookMap(() => new SyncBailHook(["declaration"])),
-			/** @type {HookMap<SyncBailHook<[DeclarationNode], boolean | void>>} */
+			/** @type {HookMap<SyncBailHook<[Declaration], boolean | void>>} */
 			varDeclarationConst: new HookMap(() => new SyncBailHook(["declaration"])),
-			/** @type {HookMap<SyncBailHook<[DeclarationNode], boolean | void>>} */
+			/** @type {HookMap<SyncBailHook<[Declaration], boolean | void>>} */
 			varDeclarationVar: new HookMap(() => new SyncBailHook(["declaration"])),
-			/** @type {HookMap<SyncBailHook<[IdentifierNode], boolean | void>>} */
+			/** @type {HookMap<SyncBailHook<[Identifier], boolean | void>>} */
 			pattern: new HookMap(() => new SyncBailHook(["pattern"])),
-			/** @type {HookMap<SyncBailHook<[ExpressionNode], boolean | void>>} */
+			/** @type {HookMap<SyncBailHook<[Expression], boolean | void>>} */
 			canRename: new HookMap(() => new SyncBailHook(["initExpression"])),
-			/** @type {HookMap<SyncBailHook<[ExpressionNode], boolean | void>>} */
+			/** @type {HookMap<SyncBailHook<[Expression], boolean | void>>} */
 			rename: new HookMap(() => new SyncBailHook(["initExpression"])),
-			/** @type {HookMap<SyncBailHook<[import("estree").AssignmentExpression], boolean | void>>} */
+			/** @type {HookMap<SyncBailHook<[AssignmentExpression], boolean | void>>} */
 			assign: new HookMap(() => new SyncBailHook(["expression"])),
-			/** @type {HookMap<SyncBailHook<[import("estree").AssignmentExpression, string[]], boolean | void>>} */
+			/** @type {HookMap<SyncBailHook<[AssignmentExpression, string[]], boolean | void>>} */
 			assignMemberChain: new HookMap(
 				() => new SyncBailHook(["expression", "members"])
 			),
-			/** @type {HookMap<SyncBailHook<[ExpressionNode], boolean | void>>} */
+			/** @type {HookMap<SyncBailHook<[Expression], boolean | void>>} */
 			typeof: new HookMap(() => new SyncBailHook(["expression"])),
-			/** @type {SyncBailHook<[ExpressionNode], boolean | void>} */
+			/** @type {SyncBailHook<[ImportExpression], boolean | void>} */
 			importCall: new SyncBailHook(["expression"]),
-			/** @type {SyncBailHook<[ExpressionNode], boolean | void>} */
+			/** @type {SyncBailHook<[Expression], boolean | void>} */
 			topLevelAwait: new SyncBailHook(["expression"]),
-			/** @type {HookMap<SyncBailHook<[ExpressionNode], boolean | void>>} */
+			/** @type {HookMap<SyncBailHook<[BaseCallExpression], boolean | void>>} */
 			call: new HookMap(() => new SyncBailHook(["expression"])),
 			/** Something like "a.b()" */
-			/** @type {HookMap<SyncBailHook<[CallExpressionNode, string[], boolean[]], boolean | void>>} */
+			/** @type {HookMap<SyncBailHook<[CallExpression, string[], boolean[]], boolean | void>>} */
 			callMemberChain: new HookMap(
 				() => new SyncBailHook(["expression", "members", "membersOptionals"])
 			),
 			/** Something like "a.b().c.d" */
-			/** @type {HookMap<SyncBailHook<[ExpressionNode, string[], CallExpressionNode, string[]], boolean | void>>} */
+			/** @type {HookMap<SyncBailHook<[Expression, string[], CallExpression, string[]], boolean | void>>} */
 			memberChainOfCallMemberChain: new HookMap(
 				() =>
 					new SyncBailHook([
@@ -330,7 +366,7 @@ class JavascriptParser extends Parser {
 					])
 			),
 			/** Something like "a.b().c.d()"" */
-			/** @type {HookMap<SyncBailHook<[ExpressionNode, string[], CallExpressionNode, string[]], boolean | void>>} */
+			/** @type {HookMap<SyncBailHook<[Expression, string[], CallExpression, string[]], boolean | void>>} */
 			callMemberChainOfCallMemberChain: new HookMap(
 				() =>
 					new SyncBailHook([
@@ -340,29 +376,29 @@ class JavascriptParser extends Parser {
 						"members"
 					])
 			),
-			/** @type {SyncBailHook<[ChainExpressionNode], boolean | void>} */
+			/** @type {SyncBailHook<[ChainExpression], boolean | void>} */
 			optionalChaining: new SyncBailHook(["optionalChaining"]),
-			/** @type {HookMap<SyncBailHook<[NewExpressionNode], boolean | void>>} */
+			/** @type {HookMap<SyncBailHook<[NewExpression], boolean | void>>} */
 			new: new HookMap(() => new SyncBailHook(["expression"])),
-			/** @type {SyncBailHook<[BinaryExpressionNode], boolean | void>} */
+			/** @type {SyncBailHook<[BinaryExpression], boolean | void>} */
 			binaryExpression: new SyncBailHook(["binaryExpression"]),
-			/** @type {HookMap<SyncBailHook<[ExpressionNode], boolean | void>>} */
+			/** @type {HookMap<SyncBailHook<[Expression], boolean | void>>} */
 			expression: new HookMap(() => new SyncBailHook(["expression"])),
-			/** @type {HookMap<SyncBailHook<[ExpressionNode, string[], boolean[]], boolean | void>>} */
+			/** @type {HookMap<SyncBailHook<[Expression, string[], boolean[]], boolean | void>>} */
 			expressionMemberChain: new HookMap(
 				() => new SyncBailHook(["expression", "members", "membersOptionals"])
 			),
-			/** @type {HookMap<SyncBailHook<[ExpressionNode, string[]], boolean | void>>} */
+			/** @type {HookMap<SyncBailHook<[Expression, string[]], boolean | void>>} */
 			unhandledExpressionMemberChain: new HookMap(
 				() => new SyncBailHook(["expression", "members"])
 			),
-			/** @type {SyncBailHook<[ExpressionNode], boolean | void>} */
+			/** @type {SyncBailHook<[Expression], boolean | void>} */
 			expressionConditionalOperator: new SyncBailHook(["expression"]),
-			/** @type {SyncBailHook<[ExpressionNode], boolean | void>} */
+			/** @type {SyncBailHook<[Expression], boolean | void>} */
 			expressionLogicalOperator: new SyncBailHook(["expression"]),
-			/** @type {SyncBailHook<[ProgramNode, CommentNode[]], boolean | void>} */
+			/** @type {SyncBailHook<[Program, Comment[]], boolean | void>} */
 			program: new SyncBailHook(["ast", "comments"]),
-			/** @type {SyncBailHook<[ProgramNode, CommentNode[]], boolean | void>} */
+			/** @type {SyncBailHook<[Program, Comment[]], boolean | void>} */
 			finish: new SyncBailHook(["ast", "comments"])
 		});
 		this.sourceType = sourceType;
@@ -372,10 +408,11 @@ class JavascriptParser extends Parser {
 		this.state = undefined;
 		this.comments = undefined;
 		this.semicolons = undefined;
-		/** @type {(StatementNode|ExpressionNode)[]} */
+		/** @type {(Statement | ModuleDeclaration | Expression)[]} */
 		this.statementPath = undefined;
+		/** @type {Statement | ModuleDeclaration | Expression} */
 		this.prevStatement = undefined;
-		/** @type {WeakMap<ExpressionNode, Set<string>>} */
+		/** @type {WeakMap<Expression, Set<string>>} */
 		this.destructuringAssignmentProperties = undefined;
 		this.currentTagData = undefined;
 		this._initializeEvaluating();
@@ -383,7 +420,7 @@ class JavascriptParser extends Parser {
 
 	_initializeEvaluating() {
 		this.hooks.evaluate.for("Literal").tap("JavascriptParser", _expr => {
-			const expr = /** @type {LiteralNode} */ (_expr);
+			const expr = /** @type {Literal} */ (_expr);
 
 			switch (typeof expr.value) {
 				case "number":
@@ -413,7 +450,7 @@ class JavascriptParser extends Parser {
 			}
 		});
 		this.hooks.evaluate.for("NewExpression").tap("JavascriptParser", _expr => {
-			const expr = /** @type {NewExpressionNode} */ (_expr);
+			const expr = /** @type {NewExpression} */ (_expr);
 			const callee = expr.callee;
 			if (callee.type !== "Identifier") return;
 			if (callee.name !== "RegExp") {
@@ -474,7 +511,7 @@ class JavascriptParser extends Parser {
 		this.hooks.evaluate
 			.for("LogicalExpression")
 			.tap("JavascriptParser", _expr => {
-				const expr = /** @type {LogicalExpressionNode} */ (_expr);
+				const expr = /** @type {LogicalExpression} */ (_expr);
 
 				const left = this.evaluateExpression(expr.left);
 				let returnRight = false;
@@ -533,13 +570,13 @@ class JavascriptParser extends Parser {
 		 * import("./" + foo + bar); // webpack will auto evaluate this into import("./foobar")
 		 * ```
 		 * @param {boolean | number | BigInt | string} value the value to convert to an expression
-		 * @param {BinaryExpressionNode | UnaryExpressionNode} expr the expression being evaluated
+		 * @param {BinaryExpression | UnaryExpression} expr the expression being evaluated
 		 * @param {boolean} sideEffects whether the expression has side effects
 		 * @returns {BasicEvaluatedExpression} the evaluated expression
 		 * @example
 		 *
 		 * ```js
-		 * const binaryExpr = new BinaryExpressionNode("+",
+		 * const binaryExpr = new BinaryExpression("+",
 		 * 	{ type: "Literal", value: 2 },
 		 * 	{ type: "Literal", value: 3 }
 		 * );
@@ -584,7 +621,7 @@ class JavascriptParser extends Parser {
 		this.hooks.evaluate
 			.for("BinaryExpression")
 			.tap("JavascriptParser", _expr => {
-				const expr = /** @type {BinaryExpressionNode} */ (_expr);
+				const expr = /** @type {BinaryExpression} */ (_expr);
 
 				/**
 				 * Evaluates a binary expression if and only if it is a const operation (e.g. 1 + 2, "a" + "b", etc.).
@@ -935,7 +972,7 @@ class JavascriptParser extends Parser {
 		this.hooks.evaluate
 			.for("UnaryExpression")
 			.tap("JavascriptParser", _expr => {
-				const expr = /** @type {UnaryExpressionNode} */ (_expr);
+				const expr = /** @type {UnaryExpression} */ (_expr);
 
 				/**
 				 * Evaluates a UnaryExpression if and only if it is a basic const operator (e.g. +a, -a, ~a).
@@ -1065,7 +1102,7 @@ class JavascriptParser extends Parser {
 				.setRange(expr.range);
 		});
 		this.hooks.evaluate.for("Identifier").tap("JavascriptParser", expr => {
-			if (/** @type {IdentifierNode} */ (expr).name === "undefined") {
+			if (/** @type {Identifier} */ (expr).name === "undefined") {
 				return new BasicEvaluatedExpression()
 					.setUndefined()
 					.setRange(expr.range);
@@ -1073,16 +1110,16 @@ class JavascriptParser extends Parser {
 		});
 		/**
 		 * @param {string} exprType expression type name
-		 * @param {function(ExpressionNode): GetInfoResult | undefined} getInfo get info
+		 * @param {function(Expression): GetInfoResult | undefined} getInfo get info
 		 * @returns {void}
 		 */
 		const tapEvaluateWithVariableInfo = (exprType, getInfo) => {
-			/** @type {ExpressionNode | undefined} */
+			/** @type {Expression | undefined} */
 			let cachedExpression = undefined;
 			/** @type {GetInfoResult | undefined} */
 			let cachedInfo = undefined;
 			this.hooks.evaluate.for(exprType).tap("JavascriptParser", expr => {
-				const expression = /** @type {MemberExpressionNode} */ (expr);
+				const expression = /** @type {MemberExpression} */ (expr);
 
 				const info = getInfo(expr);
 				if (info !== undefined) {
@@ -1124,9 +1161,7 @@ class JavascriptParser extends Parser {
 			});
 		};
 		tapEvaluateWithVariableInfo("Identifier", expr => {
-			const info = this.getVariableInfo(
-				/** @type {IdentifierNode} */ (expr).name
-			);
+			const info = this.getVariableInfo(/** @type {Identifier} */ (expr).name);
 			if (
 				typeof info === "string" ||
 				(info instanceof VariableInfo && typeof info.freeName === "string")
@@ -1154,7 +1189,7 @@ class JavascriptParser extends Parser {
 			}
 		});
 		this.hooks.evaluate.for("MetaProperty").tap("JavascriptParser", expr => {
-			const metaProperty = /** @type {MetaPropertyNode} */ (expr);
+			const metaProperty = /** @type {MetaProperty} */ (expr);
 
 			return this.callHooksForName(
 				this.hooks.evaluateIdentifier,
@@ -1164,13 +1199,13 @@ class JavascriptParser extends Parser {
 		});
 		tapEvaluateWithVariableInfo("MemberExpression", expr =>
 			this.getMemberExpressionInfo(
-				/** @type {MemberExpressionNode} */ (expr),
+				/** @type {MemberExpression} */ (expr),
 				ALLOWED_MEMBER_TYPES_EXPRESSION
 			)
 		);
 
 		this.hooks.evaluate.for("CallExpression").tap("JavascriptParser", _expr => {
-			const expr = /** @type {CallExpressionNode} */ (_expr);
+			const expr = /** @type {CallExpression} */ (_expr);
 			if (
 				expr.callee.type === "MemberExpression" &&
 				expr.callee.property.type ===
@@ -1178,7 +1213,7 @@ class JavascriptParser extends Parser {
 			) {
 				// type Super also possible here
 				const param = this.evaluateExpression(
-					/** @type {ExpressionNode} */ (expr.callee.object)
+					/** @type {Expression} */ (expr.callee.object)
 				);
 				const property =
 					expr.callee.property.type === "Literal"
@@ -1276,7 +1311,7 @@ class JavascriptParser extends Parser {
 
 		/**
 		 * @param {"cooked" | "raw"} kind kind of values to get
-		 * @param {TemplateLiteralNode} templateLiteralExpr TemplateLiteral expr
+		 * @param {TemplateLiteral} templateLiteralExpr TemplateLiteral expr
 		 * @returns {{quasis: BasicEvaluatedExpression[], parts: BasicEvaluatedExpression[]}} Simplified template
 		 */
 		const getSimplifiedTemplateResult = (kind, templateLiteralExpr) => {
@@ -1327,7 +1362,7 @@ class JavascriptParser extends Parser {
 		this.hooks.evaluate
 			.for("TemplateLiteral")
 			.tap("JavascriptParser", _node => {
-				const node = /** @type {TemplateLiteralNode} */ (_node);
+				const node = /** @type {TemplateLiteral} */ (_node);
 
 				const { quasis, parts } = getSimplifiedTemplateResult("cooked", node);
 				if (parts.length === 1) {
@@ -1340,7 +1375,7 @@ class JavascriptParser extends Parser {
 		this.hooks.evaluate
 			.for("TaggedTemplateExpression")
 			.tap("JavascriptParser", _node => {
-				const node = /** @type {TaggedTemplateExpressionNode} */ (_node);
+				const node = /** @type {TaggedTemplateExpression} */ (_node);
 				const tag = this.evaluateExpression(node.tag);
 
 				if (tag.isIdentifier() && tag.identifier === "String.raw") {
@@ -1380,7 +1415,7 @@ class JavascriptParser extends Parser {
 						: "" + argExpr.number;
 
 					const newString = value + (stringSuffix ? stringSuffix.string : "");
-					const newRange = /** @type {[number, number]} */ ([
+					const newRange = /** @type {Range} */ ([
 						argExpr.range[0],
 						(stringSuffix || argExpr).range[1]
 					]);
@@ -1445,7 +1480,7 @@ class JavascriptParser extends Parser {
 		this.hooks.evaluate
 			.for("ConditionalExpression")
 			.tap("JavascriptParser", _expr => {
-				const expr = /** @type {ConditionalExpressionNode} */ (_expr);
+				const expr = /** @type {ConditionalExpression} */ (_expr);
 
 				const condition = this.evaluateExpression(expr.test);
 				const conditionValue = condition.asBool();
@@ -1476,7 +1511,7 @@ class JavascriptParser extends Parser {
 		this.hooks.evaluate
 			.for("ArrayExpression")
 			.tap("JavascriptParser", _expr => {
-				const expr = /** @type {ArrayExpressionNode} */ (_expr);
+				const expr = /** @type {ArrayExpression} */ (_expr);
 
 				const items = expr.elements.map(element => {
 					return (
@@ -1493,10 +1528,10 @@ class JavascriptParser extends Parser {
 		this.hooks.evaluate
 			.for("ChainExpression")
 			.tap("JavascriptParser", _expr => {
-				const expr = /** @type {ChainExpressionNode} */ (_expr);
-				/** @type {ExpressionNode[]} */
+				const expr = /** @type {ChainExpression} */ (_expr);
+				/** @type {Expression[]} */
 				const optionalExpressionsStack = [];
-				/** @type {ExpressionNode|SuperNode} */
+				/** @type {Expression|Super} */
 				let next = expr.expression;
 
 				while (
@@ -1507,7 +1542,7 @@ class JavascriptParser extends Parser {
 						if (next.optional) {
 							// SuperNode can not be optional
 							optionalExpressionsStack.push(
-								/** @type {ExpressionNode} */ (next.object)
+								/** @type {Expression} */ (next.object)
 							);
 						}
 						next = next.object;
@@ -1515,7 +1550,7 @@ class JavascriptParser extends Parser {
 						if (next.optional) {
 							// SuperNode can not be optional
 							optionalExpressionsStack.push(
-								/** @type {ExpressionNode} */ (next.callee)
+								/** @type {Expression} */ (next.callee)
 							);
 						}
 						next = next.callee;
@@ -1535,7 +1570,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
-	 * @param {ExpressionNode} node node
+	 * @param {Expression} node node
 	 * @returns {Set<string>|undefined} destructured identifiers
 	 */
 	destructuringAssignmentPropertiesFor(node) {
@@ -1543,6 +1578,10 @@ class JavascriptParser extends Parser {
 		return this.destructuringAssignmentProperties.get(node);
 	}
 
+	/**
+	 * @param {Expression} expr expression
+	 * @returns {string | VariableInfoInterface | undefined} identifier
+	 */
 	getRenameIdentifier(expr) {
 		const result = this.evaluateExpression(expr);
 		if (result.isIdentifier()) {
@@ -1551,7 +1590,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
-	 * @param {ClassExpressionNode | ClassDeclarationNode} classy a class node
+	 * @param {ClassExpression | ClassDeclaration} classy a class node
 	 * @returns {void}
 	 */
 	walkClass(classy) {
@@ -1561,36 +1600,47 @@ class JavascriptParser extends Parser {
 			}
 		}
 		if (classy.body && classy.body.type === "ClassBody") {
-			for (const classElement of /** @type {TODO} */ (classy.body.body)) {
-				if (!this.hooks.classBodyElement.call(classElement, classy)) {
-					if (classElement.computed && classElement.key) {
-						this.walkExpression(classElement.key);
-					}
-					if (classElement.value) {
-						if (
-							!this.hooks.classBodyValue.call(
-								classElement.value,
-								classElement,
-								classy
-							)
-						) {
+			const scopeParams = [];
+			// Add class name in scope for recursive calls
+			if (classy.id) {
+				scopeParams.push(classy.id);
+			}
+			this.inClassScope(true, scopeParams, () => {
+				for (const classElement of /** @type {TODO} */ (classy.body.body)) {
+					if (!this.hooks.classBodyElement.call(classElement, classy)) {
+						if (classElement.computed && classElement.key) {
+							this.walkExpression(classElement.key);
+						}
+						if (classElement.value) {
+							if (
+								!this.hooks.classBodyValue.call(
+									classElement.value,
+									classElement,
+									classy
+								)
+							) {
+								const wasTopLevel = this.scope.topLevelScope;
+								this.scope.topLevelScope = false;
+								this.walkExpression(classElement.value);
+								this.scope.topLevelScope = wasTopLevel;
+							}
+						} else if (classElement.type === "StaticBlock") {
 							const wasTopLevel = this.scope.topLevelScope;
 							this.scope.topLevelScope = false;
-							this.walkExpression(classElement.value);
+							this.walkBlockStatement(classElement);
 							this.scope.topLevelScope = wasTopLevel;
 						}
-					} else if (classElement.type === "StaticBlock") {
-						const wasTopLevel = this.scope.topLevelScope;
-						this.scope.topLevelScope = false;
-						this.walkBlockStatement(classElement);
-						this.scope.topLevelScope = wasTopLevel;
 					}
 				}
-			}
+			});
 		}
 	}
 
-	// Pre walking iterates the scope for variable declarations
+	/**
+	 * Pre walking iterates the scope for variable declarations
+	 *
+	 * @param {(Statement | ModuleDeclaration)[]} statements statements
+	 */
 	preWalkStatements(statements) {
 		for (let index = 0, len = statements.length; index < len; index++) {
 			const statement = statements[index];
@@ -1598,7 +1648,11 @@ class JavascriptParser extends Parser {
 		}
 	}
 
-	// Block pre walking iterates the scope for block variable declarations
+	/**
+	 * Block pre walking iterates the scope for block variable declarations
+	 *
+	 * @param {(Statement | ModuleDeclaration)[]} statements statements
+	 */
 	blockPreWalkStatements(statements) {
 		for (let index = 0, len = statements.length; index < len; index++) {
 			const statement = statements[index];
@@ -1606,7 +1660,11 @@ class JavascriptParser extends Parser {
 		}
 	}
 
-	// Walking iterates the statements and expressions and processes them
+	/**
+	 * Walking iterates the statements and expressions and processes them
+	 *
+	 * @param {(Statement | ModuleDeclaration)[]} statements statements
+	 */
 	walkStatements(statements) {
 		for (let index = 0, len = statements.length; index < len; index++) {
 			const statement = statements[index];
@@ -1614,6 +1672,11 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * Walking iterates the statements and expressions and processes them
+	 *
+	 * @param {Statement | ModuleDeclaration} statement statement
+	 */
 	preWalkStatement(statement) {
 		this.statementPath.push(statement);
 		if (this.hooks.preStatement.call(statement)) {
@@ -1664,6 +1727,9 @@ class JavascriptParser extends Parser {
 		this.prevStatement = this.statementPath.pop();
 	}
 
+	/**
+	 * @param {Statement | ModuleDeclaration} statement statement
+	 */
 	blockPreWalkStatement(statement) {
 		this.statementPath.push(statement);
 		if (this.hooks.blockPreStatement.call(statement)) {
@@ -1695,6 +1761,9 @@ class JavascriptParser extends Parser {
 		this.prevStatement = this.statementPath.pop();
 	}
 
+	/**
+	 * @param {Statement | ModuleDeclaration} statement statement
+	 */
 	walkStatement(statement) {
 		this.statementPath.push(statement);
 		if (this.hooks.statement.call(statement) !== undefined) {
@@ -1767,8 +1836,8 @@ class JavascriptParser extends Parser {
 	 * Walks a statements that is nested within a parent statement
 	 * and can potentially be a non-block statement.
 	 * This enforces the nested statement to never be in ASI position.
-	 * @param {StatementNode} statement the nested statement
-	 * @returns {void}
+	 *
+	 * @param {Statement} statement the nested statement
 	 */
 	walkNestedStatement(statement) {
 		this.prevStatement = undefined;
@@ -1776,10 +1845,16 @@ class JavascriptParser extends Parser {
 	}
 
 	// Real Statements
+	/**
+	 * @param {BlockStatement} statement block statement
+	 */
 	preWalkBlockStatement(statement) {
 		this.preWalkStatements(statement.body);
 	}
 
+	/**
+	 * @param {BlockStatement} statement block statement
+	 */
 	walkBlockStatement(statement) {
 		this.inBlockScope(() => {
 			const body = statement.body;
@@ -1790,10 +1865,16 @@ class JavascriptParser extends Parser {
 		});
 	}
 
+	/**
+	 * @param {ExpressionStatement} statement expression statement
+	 */
 	walkExpressionStatement(statement) {
 		this.walkExpression(statement.expression);
 	}
 
+	/**
+	 * @param {IfStatement} statement if statement
+	 */
 	preWalkIfStatement(statement) {
 		this.preWalkStatement(statement.consequent);
 		if (statement.alternate) {
@@ -1801,6 +1882,9 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @param {IfStatement} statement if statement
+	 */
 	walkIfStatement(statement) {
 		const result = this.hooks.statementIf.call(statement);
 		if (result === undefined) {
@@ -1818,10 +1902,16 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @param {LabeledStatement} statement with statement
+	 */
 	preWalkLabeledStatement(statement) {
 		this.preWalkStatement(statement.body);
 	}
 
+	/**
+	 * @param {LabeledStatement} statement with statement
+	 */
 	walkLabeledStatement(statement) {
 		const hook = this.hooks.label.get(statement.label.name);
 		if (hook !== undefined) {
@@ -1831,42 +1921,69 @@ class JavascriptParser extends Parser {
 		this.walkNestedStatement(statement.body);
 	}
 
+	/**
+	 * @param {WithStatement} statement with statement
+	 */
 	preWalkWithStatement(statement) {
 		this.preWalkStatement(statement.body);
 	}
 
+	/**
+	 * @param {WithStatement} statement with statement
+	 */
 	walkWithStatement(statement) {
 		this.walkExpression(statement.object);
 		this.walkNestedStatement(statement.body);
 	}
 
+	/**
+	 * @param {SwitchStatement} statement switch statement
+	 */
 	preWalkSwitchStatement(statement) {
 		this.preWalkSwitchCases(statement.cases);
 	}
 
+	/**
+	 * @param {SwitchStatement} statement switch statement
+	 */
 	walkSwitchStatement(statement) {
 		this.walkExpression(statement.discriminant);
 		this.walkSwitchCases(statement.cases);
 	}
 
+	/**
+	 * @param {ReturnStatement | ThrowStatement} statement return or throw statement
+	 */
 	walkTerminatingStatement(statement) {
 		if (statement.argument) this.walkExpression(statement.argument);
 	}
 
+	/**
+	 * @param {ReturnStatement} statement return statement
+	 */
 	walkReturnStatement(statement) {
 		this.walkTerminatingStatement(statement);
 	}
 
+	/**
+	 * @param {ThrowStatement} statement return statement
+	 */
 	walkThrowStatement(statement) {
 		this.walkTerminatingStatement(statement);
 	}
 
+	/**
+	 * @param {TryStatement} statement try statement
+	 */
 	preWalkTryStatement(statement) {
 		this.preWalkStatement(statement.block);
 		if (statement.handler) this.preWalkCatchClause(statement.handler);
 		if (statement.finalizer) this.preWalkStatement(statement.finalizer);
 	}
 
+	/**
+	 * @param {TryStatement} statement try statement
+	 */
 	walkTryStatement(statement) {
 		if (this.scope.inTry) {
 			this.walkStatement(statement.block);
@@ -1879,24 +1996,39 @@ class JavascriptParser extends Parser {
 		if (statement.finalizer) this.walkStatement(statement.finalizer);
 	}
 
+	/**
+	 * @param {WhileStatement} statement while statement
+	 */
 	preWalkWhileStatement(statement) {
 		this.preWalkStatement(statement.body);
 	}
 
+	/**
+	 * @param {WhileStatement} statement while statement
+	 */
 	walkWhileStatement(statement) {
 		this.walkExpression(statement.test);
 		this.walkNestedStatement(statement.body);
 	}
 
+	/**
+	 * @param {DoWhileStatement} statement do while statement
+	 */
 	preWalkDoWhileStatement(statement) {
 		this.preWalkStatement(statement.body);
 	}
 
+	/**
+	 * @param {DoWhileStatement} statement do while statement
+	 */
 	walkDoWhileStatement(statement) {
 		this.walkNestedStatement(statement.body);
 		this.walkExpression(statement.test);
 	}
 
+	/**
+	 * @param {ForStatement} statement for statement
+	 */
 	preWalkForStatement(statement) {
 		if (statement.init) {
 			if (statement.init.type === "VariableDeclaration") {
@@ -1906,6 +2038,9 @@ class JavascriptParser extends Parser {
 		this.preWalkStatement(statement.body);
 	}
 
+	/**
+	 * @param {ForStatement} statement for statement
+	 */
 	walkForStatement(statement) {
 		this.inBlockScope(() => {
 			if (statement.init) {
@@ -1936,6 +2071,9 @@ class JavascriptParser extends Parser {
 		});
 	}
 
+	/**
+	 * @param {ForInStatement} statement for statement
+	 */
 	preWalkForInStatement(statement) {
 		if (statement.left.type === "VariableDeclaration") {
 			this.preWalkVariableDeclaration(statement.left);
@@ -1943,6 +2081,9 @@ class JavascriptParser extends Parser {
 		this.preWalkStatement(statement.body);
 	}
 
+	/**
+	 * @param {ForInStatement} statement for statement
+	 */
 	walkForInStatement(statement) {
 		this.inBlockScope(() => {
 			if (statement.left.type === "VariableDeclaration") {
@@ -1975,6 +2116,9 @@ class JavascriptParser extends Parser {
 		this.preWalkStatement(statement.body);
 	}
 
+	/**
+	 * @param {ForOfStatement} statement for statement
+	 */
 	walkForOfStatement(statement) {
 		this.inBlockScope(() => {
 			if (statement.left.type === "VariableDeclaration") {
@@ -1997,13 +2141,18 @@ class JavascriptParser extends Parser {
 		});
 	}
 
-	// Declarations
+	/**
+	 * @param {FunctionDeclaration} statement function declaration
+	 */
 	preWalkFunctionDeclaration(statement) {
 		if (statement.id) {
 			this.defineVariable(statement.id.name);
 		}
 	}
 
+	/**
+	 * @param {FunctionDeclaration} statement function declaration
+	 */
 	walkFunctionDeclaration(statement) {
 		const wasTopLevel = this.scope.topLevelScope;
 		this.scope.topLevelScope = false;
@@ -2024,6 +2173,9 @@ class JavascriptParser extends Parser {
 		this.scope.topLevelScope = wasTopLevel;
 	}
 
+	/**
+	 * @param {ExpressionStatement} statement expression statement
+	 */
 	blockPreWalkExpressionStatement(statement) {
 		const expression = statement.expression;
 		switch (expression.type) {
@@ -2032,6 +2184,9 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @param {AssignmentExpression} expression assignment expression
+	 */
 	preWalkAssignmentExpression(expression) {
 		if (
 			expression.left.type !== "ObjectPattern" ||
@@ -2172,6 +2327,9 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @param {ExportNamedDeclaration} statement the statement
+	 */
 	walkExportNamedDeclaration(statement) {
 		if (statement.declaration) {
 			this.walkStatement(statement.declaration);
@@ -2239,11 +2397,17 @@ class JavascriptParser extends Parser {
 		this.hooks.exportImportSpecifier.call(statement, source, null, name, 0);
 	}
 
+	/**
+	 * @param {VariableDeclaration} statement variable declaration
+	 */
 	preWalkVariableDeclaration(statement) {
 		if (statement.kind !== "var") return;
 		this._preWalkVariableDeclaration(statement, this.hooks.varDeclarationVar);
 	}
 
+	/**
+	 * @param {VariableDeclaration} statement variable declaration
+	 */
 	blockPreWalkVariableDeclaration(statement) {
 		if (statement.kind === "var") return;
 		const hookMap =
@@ -2253,6 +2417,10 @@ class JavascriptParser extends Parser {
 		this._preWalkVariableDeclaration(statement, hookMap);
 	}
 
+	/**
+	 * @param {VariableDeclaration} statement variable declaration
+	 * @param {TODO} hookMap map of hooks
+	 */
 	_preWalkVariableDeclaration(statement, hookMap) {
 		for (const declarator of statement.declarations) {
 			switch (declarator.type) {
@@ -2299,6 +2467,9 @@ class JavascriptParser extends Parser {
 		return ids;
 	}
 
+	/**
+	 * @param {VariableDeclarator} declarator variable declarator
+	 */
 	preWalkVariableDeclarator(declarator) {
 		if (
 			!declarator.init ||
@@ -2321,6 +2492,9 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @param {VariableDeclaration} statement variable declaration
+	 */
 	walkVariableDeclaration(statement) {
 		for (const declarator of statement.declarations) {
 			switch (declarator.type) {
@@ -2348,16 +2522,25 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @param {ClassDeclaration} statement class declaration
+	 */
 	blockPreWalkClassDeclaration(statement) {
 		if (statement.id) {
 			this.defineVariable(statement.id.name);
 		}
 	}
 
+	/**
+	 * @param {ClassDeclaration} statement class declaration
+	 */
 	walkClassDeclaration(statement) {
 		this.walkClass(statement);
 	}
 
+	/**
+	 * @param {SwitchCase[]} switchCases switch statement
+	 */
 	preWalkSwitchCases(switchCases) {
 		for (let index = 0, len = switchCases.length; index < len; index++) {
 			const switchCase = switchCases[index];
@@ -2365,6 +2548,9 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @param {SwitchCase[]} switchCases switch statement
+	 */
 	walkSwitchCases(switchCases) {
 		this.inBlockScope(() => {
 			const len = switchCases.length;
@@ -2400,10 +2586,16 @@ class JavascriptParser extends Parser {
 		});
 	}
 
+	/**
+	 * @param {CatchClause} catchClause catch clause
+	 */
 	preWalkCatchClause(catchClause) {
 		this.preWalkStatement(catchClause.body);
 	}
 
+	/**
+	 * @param {CatchClause} catchClause catch clause
+	 */
 	walkCatchClause(catchClause) {
 		this.inBlockScope(() => {
 			// Error binding is optional in catch clause since ECMAScript 2019
@@ -2420,6 +2612,9 @@ class JavascriptParser extends Parser {
 		});
 	}
 
+	/**
+	 * @param {Pattern} pattern pattern
+	 */
 	walkPattern(pattern) {
 		switch (pattern.type) {
 			case "ArrayPattern":
@@ -2440,6 +2635,9 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @param {AssignmentPattern} pattern assignment pattern
+	 */
 	walkAssignmentPattern(pattern) {
 		this.walkExpression(pattern.right);
 		this.walkPattern(pattern.left);
@@ -2455,6 +2653,9 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @param {ArrayPattern} pattern array pattern
+	 */
 	walkArrayPattern(pattern) {
 		for (let i = 0, len = pattern.elements.length; i < len; i++) {
 			const element = pattern.elements[i];
@@ -2462,10 +2663,16 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @param {RestElement} pattern rest element
+	 */
 	walkRestElement(pattern) {
 		this.walkPattern(pattern.argument);
 	}
 
+	/**
+	 * @param {(Expression | SpreadElement | null)[]} expressions expressions
+	 */
 	walkExpressions(expressions) {
 		for (const expression of expressions) {
 			if (expression) {
@@ -2554,24 +2761,36 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @param {AwaitExpression} expression await expression
+	 */
 	walkAwaitExpression(expression) {
 		if (this.scope.topLevelScope === true)
 			this.hooks.topLevelAwait.call(expression);
 		this.walkExpression(expression.argument);
 	}
 
+	/**
+	 * @param {ArrayExpression} expression array expression
+	 */
 	walkArrayExpression(expression) {
 		if (expression.elements) {
 			this.walkExpressions(expression.elements);
 		}
 	}
 
+	/**
+	 * @param {SpreadElement} expression spread element
+	 */
 	walkSpreadElement(expression) {
 		if (expression.argument) {
 			this.walkExpression(expression.argument);
 		}
 	}
 
+	/**
+	 * @param {ObjectExpression} expression object expression
+	 */
 	walkObjectExpression(expression) {
 		for (
 			let propIndex = 0, len = expression.properties.length;
@@ -2583,6 +2802,9 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @param {Property | SpreadElement} prop property or spread element
+	 */
 	walkProperty(prop) {
 		if (prop.type === "SpreadElement") {
 			this.walkExpression(prop.argument);
@@ -2600,6 +2822,9 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @param {FunctionExpression} expression arrow function expression
+	 */
 	walkFunctionExpression(expression) {
 		const wasTopLevel = this.scope.topLevelScope;
 		this.scope.topLevelScope = false;
@@ -2607,7 +2832,7 @@ class JavascriptParser extends Parser {
 
 		// Add function name in scope for recursive calls
 		if (expression.id) {
-			scopeParams.push(expression.id.name);
+			scopeParams.push(expression.id);
 		}
 
 		this.inFunctionScope(true, scopeParams, () => {
@@ -2627,6 +2852,9 @@ class JavascriptParser extends Parser {
 		this.scope.topLevelScope = wasTopLevel;
 	}
 
+	/**
+	 * @param {ArrowFunctionExpression} expression arrow function expression
+	 */
 	walkArrowFunctionExpression(expression) {
 		const wasTopLevel = this.scope.topLevelScope;
 		this.scope.topLevelScope = wasTopLevel ? "arrow" : false;
@@ -2648,7 +2876,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
-	 * @param {SequenceExpressionNode} expression the sequence
+	 * @param {SequenceExpression} expression the sequence
 	 */
 	walkSequenceExpression(expression) {
 		if (!expression.expressions) return;
@@ -2672,10 +2900,16 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @param {UpdateExpression} expression the update expression
+	 */
 	walkUpdateExpression(expression) {
 		this.walkExpression(expression.argument);
 	}
 
+	/**
+	 * @param {UnaryExpression} expression the unary expression
+	 */
 	walkUnaryExpression(expression) {
 		if (expression.operator === "typeof") {
 			const result = this.callHooksForExpression(
@@ -2696,17 +2930,26 @@ class JavascriptParser extends Parser {
 		this.walkExpression(expression.argument);
 	}
 
+	/**
+	 * @param {LogicalExpression | BinaryExpression} expression the expression
+	 */
 	walkLeftRightExpression(expression) {
 		this.walkExpression(expression.left);
 		this.walkExpression(expression.right);
 	}
 
+	/**
+	 * @param {BinaryExpression} expression the binary expression
+	 */
 	walkBinaryExpression(expression) {
 		if (this.hooks.binaryExpression.call(expression) === undefined) {
 			this.walkLeftRightExpression(expression);
 		}
 	}
 
+	/**
+	 * @param {LogicalExpression} expression the logical expression
+	 */
 	walkLogicalExpression(expression) {
 		const result = this.hooks.expressionLogicalOperator.call(expression);
 		if (result === undefined) {
@@ -2718,6 +2961,9 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @param {AssignmentExpression} expression assignment expression
+	 */
 	walkAssignmentExpression(expression) {
 		if (expression.left.type === "Identifier") {
 			const renameIdentifier = this.getRenameIdentifier(expression.right);
@@ -2788,6 +3034,9 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @param {ConditionalExpression} expression conditional expression
+	 */
 	walkConditionalExpression(expression) {
 		const result = this.hooks.expressionConditionalOperator.call(expression);
 		if (result === undefined) {
@@ -2805,6 +3054,9 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @param {NewExpression} expression new expression
+	 */
 	walkNewExpression(expression) {
 		const result = this.callHooksForExpression(
 			this.hooks.new,
@@ -2818,18 +3070,27 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @param {YieldExpression} expression yield expression
+	 */
 	walkYieldExpression(expression) {
 		if (expression.argument) {
 			this.walkExpression(expression.argument);
 		}
 	}
 
+	/**
+	 * @param {TemplateLiteral} expression template literal
+	 */
 	walkTemplateLiteral(expression) {
 		if (expression.expressions) {
 			this.walkExpressions(expression.expressions);
 		}
 	}
 
+	/**
+	 * @param {TaggedTemplateExpression} expression tagged template expression
+	 */
 	walkTaggedTemplateExpression(expression) {
 		if (expression.tag) {
 			this.walkExpression(expression.tag);
@@ -2839,12 +3100,15 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @param {ClassExpression} expression the class expression
+	 */
 	walkClassExpression(expression) {
 		this.walkClass(expression);
 	}
 
 	/**
-	 * @param {ChainExpressionNode} expression expression
+	 * @param {ChainExpression} expression expression
 	 */
 	walkChainExpression(expression) {
 		const result = this.hooks.optionalChaining.call(expression);
@@ -2922,6 +3186,9 @@ class JavascriptParser extends Parser {
 		this.scope.topLevelScope = wasTopLevel;
 	}
 
+	/**
+	 * @param {ImportExpression} expression import expression
+	 */
 	walkImportExpression(expression) {
 		let result = this.hooks.importCall.call(expression);
 		if (result === true) return;
@@ -3006,6 +3273,9 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @param {MemberExpression} expression member expression
+	 */
 	walkMemberExpression(expression) {
 		const exprInfo = this.getMemberExpressionInfo(
 			expression,
@@ -3099,16 +3369,22 @@ class JavascriptParser extends Parser {
 		if (expression.computed === true) this.walkExpression(expression.property);
 	}
 
+	/**
+	 * @param {ThisExpression} expression this expression
+	 */
 	walkThisExpression(expression) {
 		this.callHooksForName(this.hooks.expression, "this", expression);
 	}
 
+	/**
+	 * @param {Identifier} expression identifier
+	 */
 	walkIdentifier(expression) {
 		this.callHooksForName(this.hooks.expression, expression.name, expression);
 	}
 
 	/**
-	 * @param {MetaPropertyNode} metaProperty meta property
+	 * @param {MetaProperty} metaProperty meta property
 	 */
 	walkMetaProperty(metaProperty) {
 		this.hooks.expression.for(getRootName(metaProperty)).call(metaProperty);
@@ -3128,7 +3404,7 @@ class JavascriptParser extends Parser {
 	 * @template T
 	 * @template R
 	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks the should be called
-	 * @param {MemberExpressionNode} expr expression info
+	 * @param {MemberExpression} expr expression info
 	 * @param {function(string, string | ScopeInfo | VariableInfo, function(): string[]): any} fallback callback when variable in not handled by hooks
 	 * @param {function(string): any} defined callback when variable is defined
 	 * @param {AsArray<T>} args args for the hook
@@ -3292,6 +3568,30 @@ class JavascriptParser extends Parser {
 		this.scope = oldScope;
 	}
 
+	inClassScope(hasThis, params, fn) {
+		const oldScope = this.scope;
+		this.scope = {
+			topLevelScope: oldScope.topLevelScope,
+			inTry: false,
+			inShorthand: false,
+			isStrict: oldScope.isStrict,
+			isAsmJs: oldScope.isAsmJs,
+			definitions: oldScope.definitions.createChild()
+		};
+
+		if (hasThis) {
+			this.undefineVariable("this");
+		}
+
+		this.enterPatterns(params, (ident, pattern) => {
+			this.defineVariable(ident);
+		});
+
+		fn();
+
+		this.scope = oldScope;
+	}
+
 	inFunctionScope(hasThis, params, fn) {
 		const oldScope = this.scope;
 		this.scope = {
@@ -3385,12 +3685,20 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @param {Identifier} pattern identifier pattern
+	 * @param {TODO} onIdent callback
+	 */
 	enterIdentifier(pattern, onIdent) {
 		if (!this.callHooksForName(this.hooks.pattern, pattern.name, pattern)) {
 			onIdent(pattern.name, pattern);
 		}
 	}
 
+	/**
+	 * @param {ObjectPattern} pattern object pattern
+	 * @param {TODO} onIdent callback
+	 */
 	enterObjectPattern(pattern, onIdent) {
 		for (
 			let propIndex = 0, len = pattern.properties.length;
@@ -3402,6 +3710,10 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @param {ArrayPattern} pattern object pattern
+	 * @param {TODO} onIdent callback
+	 */
 	enterArrayPattern(pattern, onIdent) {
 		for (
 			let elementIndex = 0, len = pattern.elements.length;
@@ -3409,20 +3721,29 @@ class JavascriptParser extends Parser {
 			elementIndex++
 		) {
 			const element = pattern.elements[elementIndex];
+			// TODO check on `null`?
 			this.enterPattern(element, onIdent);
 		}
 	}
 
+	/**
+	 * @param {RestElement} pattern object pattern
+	 * @param {TODO} onIdent callback
+	 */
 	enterRestElement(pattern, onIdent) {
 		this.enterPattern(pattern.argument, onIdent);
 	}
 
+	/**
+	 * @param {AssignmentPattern} pattern object pattern
+	 * @param {TODO} onIdent callback
+	 */
 	enterAssignmentPattern(pattern, onIdent) {
 		this.enterPattern(pattern.left, onIdent);
 	}
 
 	/**
-	 * @param {ExpressionNode} expression expression node
+	 * @param {Expression} expression expression node
 	 * @returns {BasicEvaluatedExpression} evaluation result
 	 */
 	evaluateExpression(expression) {
@@ -3444,6 +3765,10 @@ class JavascriptParser extends Parser {
 			.setExpression(expression);
 	}
 
+	/**
+	 * @param {Expression} expression expression
+	 * @returns {string} parsed string
+	 */
 	parseString(expression) {
 		switch (expression.type) {
 			case "BinaryExpression":
@@ -3552,7 +3877,7 @@ class JavascriptParser extends Parser {
 			source = source.toString("utf-8");
 		}
 		if (typeof source === "object") {
-			ast = /** @type {ProgramNode} */ (source);
+			ast = /** @type {Program} */ (source);
 			comments = source.comments;
 		} else {
 			comments = [];
@@ -3620,7 +3945,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
-	 * @param {ExpressionNode | DeclarationNode | PrivateIdentifierNode | null | undefined} expr an expression
+	 * @param {Expression | Declaration | PrivateIdentifier | null | undefined} expr an expression
 	 * @param {number} commentsStartPos source position from which annotation comments are checked
 	 * @returns {boolean} true, when the expression is pure
 	 */
@@ -3638,21 +3963,34 @@ class JavascriptParser extends Parser {
 					return false;
 				}
 				const items =
-					/** @type {(MethodDefinitionNode | PropertyDefinitionNode)[]} */ (
-						expr.body.body
-					);
-				return items.every(
-					item =>
-						(!item.computed ||
-							!item.key ||
-							this.isPure(item.key, item.range[0])) &&
-						(!item.static ||
-							!item.value ||
-							this.isPure(
-								item.value,
-								item.key ? item.key.range[1] : item.range[0]
-							))
-				);
+					/** @type {TODO[]} */
+					(expr.body.body);
+				return items.every(item => {
+					if (
+						item.computed &&
+						item.key &&
+						!this.isPure(item.key, item.range[0])
+					) {
+						return false;
+					}
+
+					if (
+						item.static &&
+						item.value &&
+						!this.isPure(
+							item.value,
+							item.key ? item.key.range[1] : item.range[0]
+						)
+					) {
+						return false;
+					}
+
+					if (item.type === "StaticBlock") {
+						return false;
+					}
+
+					return true;
+				});
 			}
 
 			case "FunctionDeclaration":
@@ -3703,6 +4041,10 @@ class JavascriptParser extends Parser {
 		return !evaluated.couldHaveSideEffects();
 	}
 
+	/**
+	 * @param {Range} range range
+	 * @returns {TODO[]} comments in the range
+	 */
 	getComments(range) {
 		const [rangeStart, rangeEnd] = range;
 		const compare = (comment, needle) => comment.range[0] - needle;
@@ -3790,6 +4132,9 @@ class JavascriptParser extends Parser {
 		this.scope.definitions.set(name, newInfo);
 	}
 
+	/**
+	 * @param {string} name variable name
+	 */
 	defineVariable(name) {
 		const oldInfo = this.scope.definitions.get(name);
 		// Don't redefine variable in same scope to keep existing tags
@@ -3798,10 +4143,17 @@ class JavascriptParser extends Parser {
 		this.scope.definitions.set(name, this.scope);
 	}
 
+	/**
+	 * @param {string} name variable name
+	 */
 	undefineVariable(name) {
 		this.scope.definitions.delete(name);
 	}
 
+	/**
+	 * @param {string} name variable name
+	 * @returns {boolean} true, when variable is defined
+	 */
 	isVariableDefined(name) {
 		const info = this.scope.definitions.get(name);
 		if (info === undefined) return false;
@@ -3844,10 +4196,18 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @param {TagInfo} tagInfo tag info
+	 * @returns {VariableInfo} variable info
+	 */
 	evaluatedVariable(tagInfo) {
 		return new VariableInfo(this.scope, undefined, tagInfo);
 	}
 
+	/**
+	 * @param {Range} range range of the comment
+	 * @returns {TODO} TODO
+	 */
 	parseCommentOptions(range) {
 		const comments = this.getComments(range);
 		if (comments.length === 0) {
@@ -3882,8 +4242,8 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
-	 * @param {MemberExpressionNode} expression a member expression
-	 * @returns {{ members: string[], object: ExpressionNode | SuperNode, membersOptionals: boolean[] }} member names (reverse order) and remaining object
+	 * @param {MemberExpression} expression a member expression
+	 * @returns {{ members: string[], object: Expression | Super, membersOptionals: boolean[] }} member names (reverse order) and remaining object
 	 */
 	extractMemberExpressionChain(expression) {
 		/** @type {AnyNode} */
@@ -3927,11 +4287,11 @@ class JavascriptParser extends Parser {
 		return { info, name };
 	}
 
-	/** @typedef {{ type: "call", call: CallExpressionNode, calleeName: string, rootInfo: string | VariableInfo, getCalleeMembers: () => string[], name: string, getMembers: () => string[], getMembersOptionals: () => boolean[]}} CallExpressionInfo */
+	/** @typedef {{ type: "call", call: CallExpression, calleeName: string, rootInfo: string | VariableInfo, getCalleeMembers: () => string[], name: string, getMembers: () => string[], getMembersOptionals: () => boolean[]}} CallExpressionInfo */
 	/** @typedef {{ type: "expression", rootInfo: string | VariableInfo, name: string, getMembers: () => string[], getMembersOptionals: () => boolean[]}} ExpressionExpressionInfo */
 
 	/**
-	 * @param {MemberExpressionNode} expression a member expression
+	 * @param {MemberExpression} expression a member expression
 	 * @param {number} allowedTypes which types should be returned, presented in bit mask
 	 * @returns {CallExpressionInfo | ExpressionExpressionInfo | undefined} expression info
 	 */
@@ -3988,7 +4348,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
-	 * @param {MemberExpressionNode} expression an expression
+	 * @param {MemberExpression} expression an expression
 	 * @returns {{ name: string, rootInfo: ExportedVariableInfo, getMembers: () => string[]}} name info
 	 */
 	getNameForExpression(expression) {
@@ -4001,7 +4361,7 @@ class JavascriptParser extends Parser {
 	/**
 	 * @param {string} code source code
 	 * @param {ParseOptions} options parsing options
-	 * @returns {ProgramNode} parsed ast
+	 * @returns {Program} parsed ast
 	 */
 	static _parse(code, options) {
 		const type = options ? options.sourceType : "module";
@@ -4045,7 +4405,7 @@ class JavascriptParser extends Parser {
 			throw error;
 		}
 
-		return /** @type {ProgramNode} */ (ast);
+		return /** @type {Program} */ (ast);
 	}
 }