webpack 5.76.1 → 5.88.2

package/lib/javascript/JavascriptParser.js

@@ -16,48 +16,83 @@ 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").ChainElement} ChainElement */
+/** @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 */
 /** @typedef {{declaredScope: ScopeInfo, freeName: string | true, tagInfo: TagInfo | undefined}} VariableInfoInterface */
-/** @typedef {{ name: string | VariableInfo, rootInfo: string | VariableInfo, getMembers: () => string[], getMembersOptionals: () => boolean[] }} GetInfoResult */
+/** @typedef {{ name: string | VariableInfo, rootInfo: string | VariableInfo, getMembers: () => string[], getMembersOptionals: () => boolean[], getMemberRanges: () => Range[] }} GetInfoResult */
 
 const EMPTY_ARRAY = [];
 const ALLOWED_MEMBER_TYPES_CALL_EXPRESSION = 0b01;
@@ -71,7 +106,7 @@ const parser = AcornParser.extend(importAssertions);
 class VariableInfo {
 	/**
 	 * @param {ScopeInfo} declaredScope scope in which the variable is declared
-	 * @param {string | true} freeName which free name the variable aliases, or true when none
+	 * @param {string | true | undefined} freeName which free name the variable aliases, or true when none
 	 * @param {TagInfo | undefined} tagInfo info about tags
 	 */
 	constructor(declaredScope, freeName, tagInfo) {
@@ -82,7 +117,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,18 +131,55 @@ class VariableInfo {
  * @typedef {Object} ScopeInfo
  * @property {StackedMap<string, VariableInfo | ScopeInfo>} definitions
  * @property {boolean | "arrow"} topLevelScope
- * @property {boolean} inShorthand
+ * @property {boolean | string} inShorthand
+ * @property {boolean} inTaggedTemplateTag
+ * @property {boolean} inTry
  * @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
+ * to create the range of the _parent node_.
+ *
+ * @param {[number, number]} startRange start range to join
+ * @param {[number, number]} endRange end range to join
+ * @returns {[number, number]} joined range
+ *
+ * @example
+ * ```js
+ * 	const startRange = [0, 5];
+ * 	const endRange = [10, 15];
+ * 	const joinedRange = joinRanges(startRange, endRange);
+ * 	console.log(joinedRange); // [0, 15]
+ * ```
+ *
+ */
 const joinRanges = (startRange, endRange) => {
 	if (!endRange) return startRange;
 	if (!startRange) return endRange;
 	return [startRange[0], endRange[1]];
 };
 
+/**
+ * Helper function used to generate a string representation of a
+ * [member expression](https://github.com/estree/estree/blob/master/es5.md#memberexpression).
+ *
+ * @param {string} object object to name
+ * @param {string[]} membersReversed reversed list of members
+ * @returns {string} member expression as a string
+ * @example
+ * ```js
+ * const membersReversed = ["property1", "property2", "property3"]; // Members parsed from the AST
+ * const name = objectAndMembersToName("myObject", membersReversed);
+ *
+ * console.log(name); // "myObject.property1.property2.property3"
+ * ```
+ *
+ */
 const objectAndMembersToName = (object, membersReversed) => {
 	let name = object;
 	for (let i = membersReversed.length - 1; i >= 0; i--) {
@@ -116,6 +188,16 @@ const objectAndMembersToName = (object, membersReversed) => {
 	return name;
 };
 
+/**
+ * Grabs the name of a given expression and returns it as a string or undefined. Has particular
+ * handling for [Identifiers](https://github.com/estree/estree/blob/master/es5.md#identifier),
+ * [ThisExpressions](https://github.com/estree/estree/blob/master/es5.md#identifier), and
+ * [MetaProperties](https://github.com/estree/estree/blob/master/es2015.md#metaproperty) which is
+ * specifically for handling the `new.target` meta property.
+ *
+ * @param {Expression | Super} expression expression
+ * @returns {string | "this" | undefined} name or variable info
+ */
 const getRootName = expression => {
 	switch (expression.type) {
 		case "Identifier":
@@ -155,81 +237,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",
@@ -237,45 +319,51 @@ 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<[CallExpression], 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[], Range[]], boolean | void>>} */
 			callMemberChain: new HookMap(
-				() => new SyncBailHook(["expression", "members", "membersOptionals"])
+				() =>
+					new SyncBailHook([
+						"expression",
+						"members",
+						"membersOptionals",
+						"memberRanges"
+					])
 			),
 			/** 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([
@@ -286,7 +374,7 @@ class JavascriptParser extends Parser {
 					])
 			),
 			/** Something like "a.b().c.d()"" */
-			/** @type {HookMap<SyncBailHook<[ExpressionNode, string[], CallExpressionNode, string[]], boolean | void>>} */
+			/** @type {HookMap<SyncBailHook<[CallExpression, string[], CallExpression, string[]], boolean | void>>} */
 			callMemberChainOfCallMemberChain: new HookMap(
 				() =>
 					new SyncBailHook([
@@ -296,29 +384,35 @@ 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<[MemberExpression, string[], boolean[], Range[]], boolean | void>>} */
 			expressionMemberChain: new HookMap(
-				() => new SyncBailHook(["expression", "members", "membersOptionals"])
+				() =>
+					new SyncBailHook([
+						"expression",
+						"members",
+						"membersOptionals",
+						"memberRanges"
+					])
 			),
-			/** @type {HookMap<SyncBailHook<[ExpressionNode, string[]], boolean | void>>} */
+			/** @type {HookMap<SyncBailHook<[MemberExpression, string[]], boolean | void>>} */
 			unhandledExpressionMemberChain: new HookMap(
 				() => new SyncBailHook(["expression", "members"])
 			),
-			/** @type {SyncBailHook<[ExpressionNode], boolean | void>} */
+			/** @type {SyncBailHook<[ConditionalExpression], boolean | void>} */
 			expressionConditionalOperator: new SyncBailHook(["expression"]),
-			/** @type {SyncBailHook<[ExpressionNode], boolean | void>} */
+			/** @type {SyncBailHook<[LogicalExpression], 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;
@@ -328,46 +422,51 @@ 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 | undefined} */
 		this.prevStatement = undefined;
+		/** @type {WeakMap<Expression, Set<string>>} */
+		this.destructuringAssignmentProperties = undefined;
 		this.currentTagData = undefined;
 		this._initializeEvaluating();
 	}
 
 	_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":
 					return new BasicEvaluatedExpression()
 						.setNumber(expr.value)
-						.setRange(expr.range);
+						.setRange(/** @type {Range} */ (expr.range));
 				case "bigint":
 					return new BasicEvaluatedExpression()
 						.setBigInt(expr.value)
-						.setRange(expr.range);
+						.setRange(/** @type {Range} */ (expr.range));
 				case "string":
 					return new BasicEvaluatedExpression()
 						.setString(expr.value)
-						.setRange(expr.range);
+						.setRange(/** @type {Range} */ (expr.range));
 				case "boolean":
 					return new BasicEvaluatedExpression()
 						.setBoolean(expr.value)
-						.setRange(expr.range);
+						.setRange(/** @type {Range} */ (expr.range));
 			}
 			if (expr.value === null) {
-				return new BasicEvaluatedExpression().setNull().setRange(expr.range);
+				return new BasicEvaluatedExpression()
+					.setNull()
+					.setRange(/** @type {Range} */ (expr.range));
 			}
 			if (expr.value instanceof RegExp) {
 				return new BasicEvaluatedExpression()
 					.setRegExp(expr.value)
-					.setRange(expr.range);
+					.setRange(/** @type {Range} */ (expr.range));
 			}
 		});
 		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") {
@@ -398,7 +497,7 @@ class JavascriptParser extends Parser {
 			} else {
 				return new BasicEvaluatedExpression()
 					.setRegExp(new RegExp(""))
-					.setRange(expr.range);
+					.setRange(/** @type {Range} */ (expr.range));
 			}
 
 			const arg2 = expr.arguments[1];
@@ -423,12 +522,12 @@ class JavascriptParser extends Parser {
 
 			return new BasicEvaluatedExpression()
 				.setRegExp(flags ? new RegExp(regExp, flags) : new RegExp(regExp))
-				.setRange(expr.range);
+				.setRange(/** @type {Range} */ (expr.range));
 		});
 		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;
@@ -467,44 +566,94 @@ class JavascriptParser extends Parser {
 				}
 			});
 
+		/**
+		 * In simple logical cases, we can use valueAsExpression to assist us in evaluating the expression on
+		 * either side of a [BinaryExpression](https://github.com/estree/estree/blob/master/es5.md#binaryexpression).
+		 * This supports scenarios in webpack like conditionally `import()`'ing modules based on some simple evaluation:
+		 *
+		 * ```js
+		 * if (1 === 3) {
+		 *  import("./moduleA"); // webpack will auto evaluate this and not import the modules
+		 * }
+		 * ```
+		 *
+		 * Additional scenarios include evaluation of strings inside of dynamic import statements:
+		 *
+		 * ```js
+		 * const foo = "foo";
+		 * const bar = "bar";
+		 *
+		 * 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 {BinaryExpression | UnaryExpression} expr the expression being evaluated
+		 * @param {boolean} sideEffects whether the expression has side effects
+		 * @returns {BasicEvaluatedExpression | undefined} the evaluated expression
+		 * @example
+		 *
+		 * ```js
+		 * const binaryExpr = new BinaryExpression("+",
+		 * 	{ type: "Literal", value: 2 },
+		 * 	{ type: "Literal", value: 3 }
+		 * );
+		 *
+		 * const leftValue = 2;
+		 * const rightValue = 3;
+		 *
+		 * const leftExpr = valueAsExpression(leftValue, binaryExpr.left, false);
+		 * const rightExpr = valueAsExpression(rightValue, binaryExpr.right, false);
+		 * const result = new BasicEvaluatedExpression()
+		 * 	.setNumber(leftExpr.number + rightExpr.number)
+		 * 	.setRange(binaryExpr.range);
+		 *
+		 * console.log(result.number); // Output: 5
+		 * ```
+		 */
 		const valueAsExpression = (value, expr, sideEffects) => {
 			switch (typeof value) {
 				case "boolean":
 					return new BasicEvaluatedExpression()
 						.setBoolean(value)
 						.setSideEffects(sideEffects)
-						.setRange(expr.range);
+						.setRange(/** @type {Range} */ (expr.range));
 				case "number":
 					return new BasicEvaluatedExpression()
 						.setNumber(value)
 						.setSideEffects(sideEffects)
-						.setRange(expr.range);
+						.setRange(/** @type {Range} */ (expr.range));
 				case "bigint":
 					return new BasicEvaluatedExpression()
 						.setBigInt(value)
 						.setSideEffects(sideEffects)
-						.setRange(expr.range);
+						.setRange(/** @type {Range} */ (expr.range));
 				case "string":
 					return new BasicEvaluatedExpression()
 						.setString(value)
 						.setSideEffects(sideEffects)
-						.setRange(expr.range);
+						.setRange(/** @type {Range} */ (expr.range));
 			}
 		};
 
 		this.hooks.evaluate
 			.for("BinaryExpression")
 			.tap("JavascriptParser", _expr => {
-				const expr = /** @type {BinaryExpressionNode} */ (_expr);
-
-				const handleConstOperation = fn => {
+				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.).
+				 *
+				 * @template T
+				 * @param {(leftOperand: T, rightOperand: T) => boolean | number | BigInt | string} operandHandler the handler for the operation (e.g. (a, b) => a + b)
+				 * @returns {BasicEvaluatedExpression | undefined} the evaluated expression
+				 */
+				const handleConstOperation = operandHandler => {
 					const left = this.evaluateExpression(expr.left);
 					if (!left.isCompileTimeValue()) return;
 
 					const right = this.evaluateExpression(expr.right);
 					if (!right.isCompileTimeValue()) return;
 
-					const result = fn(
+					const result = operandHandler(
 						left.asCompileTimeValue(),
 						right.asCompileTimeValue()
 					);
@@ -515,6 +664,14 @@ class JavascriptParser extends Parser {
 					);
 				};
 
+				/**
+				 * Helper function to determine if two booleans are always different. This is used in `handleStrictEqualityComparison`
+				 * to determine if an expressions boolean or nullish conversion is equal or not.
+				 *
+				 * @param {boolean} a first boolean to compare
+				 * @param {boolean} b second boolean to compare
+				 * @returns {boolean} true if the two booleans are always different, false otherwise
+				 */
 				const isAlwaysDifferent = (a, b) =>
 					(a === true && b === false) || (a === false && b === true);
 
@@ -543,11 +700,13 @@ class JavascriptParser extends Parser {
 					const rightSuffix = getSuffix(right.parts);
 					const lenPrefix = Math.min(leftPrefix.length, rightPrefix.length);
 					const lenSuffix = Math.min(leftSuffix.length, rightSuffix.length);
-					if (
-						leftPrefix.slice(0, lenPrefix) !==
-							rightPrefix.slice(0, lenPrefix) ||
-						leftSuffix.slice(-lenSuffix) !== rightSuffix.slice(-lenSuffix)
-					) {
+					const prefixMismatch =
+						lenPrefix > 0 &&
+						leftPrefix.slice(0, lenPrefix) !== rightPrefix.slice(0, lenPrefix);
+					const suffixMismatch =
+						lenSuffix > 0 &&
+						leftSuffix.slice(-lenSuffix) !== rightSuffix.slice(-lenSuffix);
+					if (prefixMismatch || suffixMismatch) {
 						return res
 							.setBoolean(!eql)
 							.setSideEffects(
@@ -556,11 +715,16 @@ class JavascriptParser extends Parser {
 					}
 				};
 
+				/**
+				 * Helper function to handle BinaryExpressions using strict equality comparisons (e.g. "===" and "!==").
+				 * @param {boolean} eql true for "===" and false for "!=="
+				 * @returns {BasicEvaluatedExpression | undefined} the evaluated expression
+				 */
 				const handleStrictEqualityComparison = eql => {
 					const left = this.evaluateExpression(expr.left);
 					const right = this.evaluateExpression(expr.right);
 					const res = new BasicEvaluatedExpression();
-					res.setRange(expr.range);
+					res.setRange(/** @type {Range} */ (expr.range));
 
 					const leftConst = left.isCompileTimeValue();
 					const rightConst = right.isCompileTimeValue();
@@ -598,8 +762,14 @@ class JavascriptParser extends Parser {
 						(rightPrimitive === false &&
 							(rightConst || leftPrimitive === true)) ||
 						// Different nullish or boolish status also means not equal
-						isAlwaysDifferent(left.asBool(), right.asBool()) ||
-						isAlwaysDifferent(left.asNullish(), right.asNullish())
+						isAlwaysDifferent(
+							/** @type {boolean} */ (left.asBool()),
+							/** @type {boolean} */ (right.asBool())
+						) ||
+						isAlwaysDifferent(
+							/** @type {boolean} */ (left.asNullish()),
+							/** @type {boolean} */ (right.asNullish())
+						)
 					) {
 						return res
 							.setBoolean(!eql)
@@ -609,6 +779,11 @@ class JavascriptParser extends Parser {
 					}
 				};
 
+				/**
+				 * Helper function to handle BinaryExpressions using abstract equality comparisons (e.g. "==" and "!=").
+				 * @param {boolean} eql true for "==" and false for "!="
+				 * @returns {BasicEvaluatedExpression | undefined} the evaluated expression
+				 */
 				const handleAbstractEqualityComparison = eql => {
 					const left = this.evaluateExpression(expr.left);
 					const right = this.evaluateExpression(expr.right);
@@ -819,12 +994,19 @@ class JavascriptParser extends Parser {
 		this.hooks.evaluate
 			.for("UnaryExpression")
 			.tap("JavascriptParser", _expr => {
-				const expr = /** @type {UnaryExpressionNode} */ (_expr);
-
-				const handleConstOperation = fn => {
+				const expr = /** @type {UnaryExpression} */ (_expr);
+
+				/**
+				 * Evaluates a UnaryExpression if and only if it is a basic const operator (e.g. +a, -a, ~a).
+				 *
+				 * @template T
+				 * @param {(operand: T) => boolean | number | BigInt | string} operandHandler handler for the operand
+				 * @returns {BasicEvaluatedExpression | undefined} evaluated expression
+				 */
+				const handleConstOperation = operandHandler => {
 					const argument = this.evaluateExpression(expr.argument);
 					if (!argument.isCompileTimeValue()) return;
-					const result = fn(argument.asCompileTimeValue());
+					const result = operandHandler(argument.asCompileTimeValue());
 					return valueAsExpression(
 						result,
 						expr,
@@ -942,7 +1124,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);
@@ -950,16 +1132,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) {
@@ -990,7 +1172,8 @@ class JavascriptParser extends Parser {
 								info.name,
 								info.rootInfo,
 								info.getMembers,
-								info.getMembersOptionals
+								info.getMembersOptionals,
+								info.getMemberRanges
 							)
 							.setRange(expr.range);
 					}
@@ -1001,9 +1184,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")
@@ -1012,7 +1193,8 @@ class JavascriptParser extends Parser {
 					name: info,
 					rootInfo: info,
 					getMembers: () => [],
-					getMembersOptionals: () => []
+					getMembersOptionals: () => [],
+					getMemberRanges: () => []
 				};
 			}
 		});
@@ -1026,12 +1208,13 @@ class JavascriptParser extends Parser {
 					name: info,
 					rootInfo: info,
 					getMembers: () => [],
-					getMembersOptionals: () => []
+					getMembersOptionals: () => [],
+					getMemberRanges: () => []
 				};
 			}
 		});
 		this.hooks.evaluate.for("MetaProperty").tap("JavascriptParser", expr => {
-			const metaProperty = /** @type {MetaPropertyNode} */ (expr);
+			const metaProperty = /** @type {MetaProperty} */ (expr);
 
 			return this.callHooksForName(
 				this.hooks.evaluateIdentifier,
@@ -1041,13 +1224,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 ===
@@ -1055,7 +1238,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"
@@ -1153,7 +1336,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) => {
@@ -1190,7 +1373,7 @@ class JavascriptParser extends Parser {
 
 				const part = new BasicEvaluatedExpression()
 					.setString(quasi)
-					.setRange(quasiExpr.range)
+					.setRange(/** @type {Range} */ (quasiExpr.range))
 					.setExpression(quasiExpr);
 				quasis.push(part);
 				parts.push(part);
@@ -1204,20 +1387,20 @@ 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) {
-					return parts[0].setRange(node.range);
+					return parts[0].setRange(/** @type {Range} */ (node.range));
 				}
 				return new BasicEvaluatedExpression()
 					.setTemplateString(quasis, parts, "cooked")
-					.setRange(node.range);
+					.setRange(/** @type {Range} */ (node.range));
 			});
 		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") {
@@ -1227,7 +1410,7 @@ class JavascriptParser extends Parser {
 					);
 					return new BasicEvaluatedExpression()
 						.setTemplateString(quasis, parts, "raw")
-						.setRange(node.range);
+						.setRange(/** @type {Range} */ (node.range));
 				}
 			});
 
@@ -1257,10 +1440,10 @@ class JavascriptParser extends Parser {
 						: "" + argExpr.number;
 
 					const newString = value + (stringSuffix ? stringSuffix.string : "");
-					const newRange = [
+					const newRange = /** @type {Range} */ ([
 						argExpr.range[0],
 						(stringSuffix || argExpr).range[1]
-					];
+					]);
 					stringSuffix = new BasicEvaluatedExpression()
 						.setString(newString)
 						.setSideEffects(
@@ -1317,12 +1500,12 @@ class JavascriptParser extends Parser {
 				return new BasicEvaluatedExpression()
 					.setArray(result)
 					.setSideEffects(param.couldHaveSideEffects())
-					.setRange(expr.range);
+					.setRange(/** @type {Range} */ (expr.range));
 			});
 		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();
@@ -1332,12 +1515,16 @@ class JavascriptParser extends Parser {
 					const alternate = this.evaluateExpression(expr.alternate);
 					res = new BasicEvaluatedExpression();
 					if (consequent.isConditional()) {
-						res.setOptions(consequent.options);
+						res.setOptions(
+							/** @type {BasicEvaluatedExpression[]} */ (consequent.options)
+						);
 					} else {
 						res.setOptions([consequent]);
 					}
 					if (alternate.isConditional()) {
-						res.addOptions(alternate.options);
+						res.addOptions(
+							/** @type {BasicEvaluatedExpression[]} */ (alternate.options)
+						);
 					} else {
 						res.addOptions([alternate]);
 					}
@@ -1347,13 +1534,13 @@ class JavascriptParser extends Parser {
 					);
 					if (condition.couldHaveSideEffects()) res.setSideEffects();
 				}
-				res.setRange(expr.range);
+				res.setRange(/** @type {Range} */ (expr.range));
 				return res;
 			});
 		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 (
@@ -1365,15 +1552,15 @@ class JavascriptParser extends Parser {
 				if (!items.every(Boolean)) return;
 				return new BasicEvaluatedExpression()
 					.setItems(items)
-					.setRange(expr.range);
+					.setRange(/** @type {Range} */ (expr.range));
 			});
 		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 (
@@ -1384,7 +1571,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;
@@ -1392,7 +1579,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;
@@ -1400,17 +1587,32 @@ class JavascriptParser extends Parser {
 				}
 
 				while (optionalExpressionsStack.length > 0) {
-					const expression = optionalExpressionsStack.pop();
+					const expression =
+						/** @type {Expression} */
+						(optionalExpressionsStack.pop());
 					const evaluated = this.evaluateExpression(expression);
 
 					if (evaluated.asNullish()) {
-						return evaluated.setRange(_expr.range);
+						return evaluated.setRange(/** @type {Range} */ (_expr.range));
 					}
 				}
 				return this.evaluateExpression(expr.expression);
 			});
 	}
 
+	/**
+	 * @param {Expression} node node
+	 * @returns {Set<string>|undefined} destructured identifiers
+	 */
+	destructuringAssignmentPropertiesFor(node) {
+		if (!this.destructuringAssignmentProperties) return undefined;
+		return this.destructuringAssignmentProperties.get(node);
+	}
+
+	/**
+	 * @param {Expression} expr expression
+	 * @returns {string | VariableInfoInterface | undefined} identifier
+	 */
 	getRenameIdentifier(expr) {
 		const result = this.evaluateExpression(expr);
 		if (result.isIdentifier()) {
@@ -1419,7 +1621,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
-	 * @param {ClassExpressionNode | ClassDeclarationNode} classy a class node
+	 * @param {ClassExpression | ClassDeclaration} classy a class node
 	 * @returns {void}
 	 */
 	walkClass(classy) {
@@ -1429,36 +1631,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];
@@ -1466,7 +1679,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];
@@ -1474,7 +1691,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];
@@ -1482,6 +1703,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)) {
@@ -1532,6 +1758,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)) {
@@ -1557,10 +1786,15 @@ class JavascriptParser extends Parser {
 			case "ClassDeclaration":
 				this.blockPreWalkClassDeclaration(statement);
 				break;
+			case "ExpressionStatement":
+				this.blockPreWalkExpressionStatement(statement);
 		}
 		this.prevStatement = this.statementPath.pop();
 	}
 
+	/**
+	 * @param {Statement | ModuleDeclaration} statement statement
+	 */
 	walkStatement(statement) {
 		this.statementPath.push(statement);
 		if (this.hooks.statement.call(statement) !== undefined) {
@@ -1633,8 +1867,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;
@@ -1642,10 +1876,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;
@@ -1656,10 +1896,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) {
@@ -1667,6 +1913,9 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @param {IfStatement} statement if statement
+	 */
 	walkIfStatement(statement) {
 		const result = this.hooks.statementIf.call(statement);
 		if (result === undefined) {
@@ -1684,10 +1933,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) {
@@ -1697,42 +1952,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.finializer) this.preWalkStatement(statement.finializer);
+		if (statement.finalizer) this.preWalkStatement(statement.finalizer);
 	}
 
+	/**
+	 * @param {TryStatement} statement try statement
+	 */
 	walkTryStatement(statement) {
 		if (this.scope.inTry) {
 			this.walkStatement(statement.block);
@@ -1745,24 +2027,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") {
@@ -1772,6 +2069,9 @@ class JavascriptParser extends Parser {
 		this.preWalkStatement(statement.body);
 	}
 
+	/**
+	 * @param {ForStatement} statement for statement
+	 */
 	walkForStatement(statement) {
 		this.inBlockScope(() => {
 			if (statement.init) {
@@ -1802,6 +2102,9 @@ class JavascriptParser extends Parser {
 		});
 	}
 
+	/**
+	 * @param {ForInStatement} statement for statement
+	 */
 	preWalkForInStatement(statement) {
 		if (statement.left.type === "VariableDeclaration") {
 			this.preWalkVariableDeclaration(statement.left);
@@ -1809,6 +2112,9 @@ class JavascriptParser extends Parser {
 		this.preWalkStatement(statement.body);
 	}
 
+	/**
+	 * @param {ForInStatement} statement for statement
+	 */
 	walkForInStatement(statement) {
 		this.inBlockScope(() => {
 			if (statement.left.type === "VariableDeclaration") {
@@ -1841,6 +2147,9 @@ class JavascriptParser extends Parser {
 		this.preWalkStatement(statement.body);
 	}
 
+	/**
+	 * @param {ForOfStatement} statement for statement
+	 */
 	walkForOfStatement(statement) {
 		this.inBlockScope(() => {
 			if (statement.left.type === "VariableDeclaration") {
@@ -1863,13 +2172,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;
@@ -1890,6 +2204,48 @@ class JavascriptParser extends Parser {
 		this.scope.topLevelScope = wasTopLevel;
 	}
 
+	/**
+	 * @param {ExpressionStatement} statement expression statement
+	 */
+	blockPreWalkExpressionStatement(statement) {
+		const expression = statement.expression;
+		switch (expression.type) {
+			case "AssignmentExpression":
+				this.preWalkAssignmentExpression(expression);
+		}
+	}
+
+	/**
+	 * @param {AssignmentExpression} expression assignment expression
+	 */
+	preWalkAssignmentExpression(expression) {
+		if (
+			expression.left.type !== "ObjectPattern" ||
+			!this.destructuringAssignmentProperties
+		)
+			return;
+		const keys = this._preWalkObjectPattern(expression.left);
+		if (!keys) return;
+
+		// check multiple assignments
+		if (this.destructuringAssignmentProperties.has(expression)) {
+			const set = this.destructuringAssignmentProperties.get(expression);
+			this.destructuringAssignmentProperties.delete(expression);
+			for (const id of set) keys.add(id);
+		}
+
+		this.destructuringAssignmentProperties.set(
+			expression.right.type === "AwaitExpression"
+				? expression.right.argument
+				: expression.right,
+			keys
+		);
+
+		if (expression.right.type === "AssignmentExpression") {
+			this.preWalkAssignmentExpression(expression.right);
+		}
+	}
+
 	blockPreWalkImportDeclaration(statement) {
 		const source = statement.source.value;
 		this.hooks.import.call(statement, source);
@@ -2002,6 +2358,9 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @param {ExportNamedDeclaration} statement the statement
+	 */
 	walkExportNamedDeclaration(statement) {
 		if (statement.declaration) {
 			this.walkStatement(statement.declaration);
@@ -2069,11 +2428,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 =
@@ -2083,10 +2448,15 @@ 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) {
 				case "VariableDeclarator": {
+					this.preWalkVariableDeclarator(declarator);
 					if (!this.hooks.preDeclarator.call(declarator, statement)) {
 						this.enterPattern(declarator.id, (name, decl) => {
 							let hook = hookMap.get(name);
@@ -2104,6 +2474,62 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @param {ObjectPattern} objectPattern object pattern
+	 * @returns {Set<string> | undefined} set of names or undefined if not all keys are identifiers
+	 */
+	_preWalkObjectPattern(objectPattern) {
+		const ids = new Set();
+		const properties = objectPattern.properties;
+		for (let i = 0; i < properties.length; i++) {
+			const property = properties[i];
+			if (property.type !== "Property") return;
+			const key = property.key;
+			if (key.type === "Identifier") {
+				ids.add(key.name);
+			} else {
+				const id = this.evaluateExpression(key);
+				const str = id.asString();
+				if (str) {
+					ids.add(str);
+				} else {
+					// could not evaluate key
+					return;
+				}
+			}
+		}
+
+		return ids;
+	}
+
+	/**
+	 * @param {VariableDeclarator} declarator variable declarator
+	 */
+	preWalkVariableDeclarator(declarator) {
+		if (
+			!declarator.init ||
+			declarator.id.type !== "ObjectPattern" ||
+			!this.destructuringAssignmentProperties
+		)
+			return;
+		const keys = this._preWalkObjectPattern(declarator.id);
+
+		if (!keys) return;
+		this.destructuringAssignmentProperties.set(
+			declarator.init.type === "AwaitExpression"
+				? declarator.init.argument
+				: declarator.init,
+			keys
+		);
+
+		if (declarator.init.type === "AssignmentExpression") {
+			this.preWalkAssignmentExpression(declarator.init);
+		}
+	}
+
+	/**
+	 * @param {VariableDeclaration} statement variable declaration
+	 */
 	walkVariableDeclaration(statement) {
 		for (const declarator of statement.declarations) {
 			switch (declarator.type) {
@@ -2131,16 +2557,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];
@@ -2148,6 +2583,9 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @param {SwitchCase[]} switchCases switch statement
+	 */
 	walkSwitchCases(switchCases) {
 		this.inBlockScope(() => {
 			const len = switchCases.length;
@@ -2183,10 +2621,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
@@ -2203,6 +2647,9 @@ class JavascriptParser extends Parser {
 		});
 	}
 
+	/**
+	 * @param {Pattern} pattern pattern
+	 */
 	walkPattern(pattern) {
 		switch (pattern.type) {
 			case "ArrayPattern":
@@ -2223,6 +2670,9 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @param {AssignmentPattern} pattern assignment pattern
+	 */
 	walkAssignmentPattern(pattern) {
 		this.walkExpression(pattern.right);
 		this.walkPattern(pattern.left);
@@ -2238,6 +2688,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];
@@ -2245,10 +2698,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) {
@@ -2257,6 +2716,9 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @param {TODO} expression expression
+	 */
 	walkExpression(expression) {
 		switch (expression.type) {
 			case "ArrayExpression":
@@ -2337,24 +2799,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;
@@ -2366,6 +2840,9 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @param {Property | SpreadElement} prop property or spread element
+	 */
 	walkProperty(prop) {
 		if (prop.type === "SpreadElement") {
 			this.walkExpression(prop.argument);
@@ -2383,14 +2860,17 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @param {FunctionExpression} expression arrow function expression
+	 */
 	walkFunctionExpression(expression) {
 		const wasTopLevel = this.scope.topLevelScope;
 		this.scope.topLevelScope = false;
-		const scopeParams = expression.params;
+		const scopeParams = [...expression.params];
 
 		// Add function name in scope for recursive calls
 		if (expression.id) {
-			scopeParams.push(expression.id.name);
+			scopeParams.push(expression.id);
 		}
 
 		this.inFunctionScope(true, scopeParams, () => {
@@ -2410,6 +2890,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;
@@ -2431,7 +2914,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
-	 * @param {SequenceExpressionNode} expression the sequence
+	 * @param {SequenceExpression} expression the sequence
 	 */
 	walkSequenceExpression(expression) {
 		if (!expression.expressions) return;
@@ -2455,10 +2938,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(
@@ -2479,17 +2968,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) {
@@ -2501,6 +2999,9 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @param {AssignmentExpression} expression assignment expression
+	 */
 	walkAssignmentExpression(expression) {
 		if (expression.left.type === "Identifier") {
 			const renameIdentifier = this.getRenameIdentifier(expression.right);
@@ -2571,6 +3072,9 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @param {ConditionalExpression} expression conditional expression
+	 */
 	walkConditionalExpression(expression) {
 		const result = this.hooks.expressionConditionalOperator.call(expression);
 		if (result === undefined) {
@@ -2588,6 +3092,9 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @param {NewExpression} expression new expression
+	 */
 	walkNewExpression(expression) {
 		const result = this.callHooksForExpression(
 			this.hooks.new,
@@ -2601,33 +3108,47 @@ 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.scope.inTaggedTemplateTag = true;
 			this.walkExpression(expression.tag);
+			this.scope.inTaggedTemplateTag = false;
 		}
 		if (expression.quasi && expression.quasi.expressions) {
 			this.walkExpressions(expression.quasi.expressions);
 		}
 	}
 
+	/**
+	 * @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);
@@ -2705,6 +3226,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;
@@ -2764,7 +3288,8 @@ class JavascriptParser extends Parser {
 					callee.getMembers(),
 					callee.getMembersOptionals
 						? callee.getMembersOptionals()
-						: callee.getMembers().map(() => false)
+						: callee.getMembers().map(() => false),
+					callee.getMemberRanges ? callee.getMemberRanges() : []
 				);
 				if (result1 === true) return;
 				const result2 = this.callHooksForInfo(
@@ -2789,6 +3314,9 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @param {MemberExpression} expression member expression
+	 */
 	walkMemberExpression(expression) {
 		const exprInfo = this.getMemberExpressionInfo(
 			expression,
@@ -2805,12 +3333,14 @@ class JavascriptParser extends Parser {
 					if (result1 === true) return;
 					const members = exprInfo.getMembers();
 					const membersOptionals = exprInfo.getMembersOptionals();
+					const memberRanges = exprInfo.getMemberRanges();
 					const result2 = this.callHooksForInfo(
 						this.hooks.expressionMemberChain,
 						exprInfo.rootInfo,
 						expression,
 						members,
-						membersOptionals
+						membersOptionals,
+						memberRanges
 					);
 					if (result2 === true) return;
 					this.walkMemberExpressionWithExpressionName(
@@ -2882,16 +3412,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);
@@ -2911,11 +3447,11 @@ 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 {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 {MemberExpression} expr expression info
+	 * @param {(function(string, string | ScopeInfo | VariableInfo, function(): string[]): any) | undefined} fallback callback when variable in not handled by hooks
+	 * @param {(function(string): any) | undefined} defined callback when variable is defined
 	 * @param {AsArray<T>} args args for the hook
-	 * @returns {R} result of hook
+	 * @returns {R | undefined} result of hook
 	 */
 	callHooksForExpressionWithFallback(
 		hookMap,
@@ -2947,7 +3483,7 @@ class JavascriptParser extends Parser {
 	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks the should be called
 	 * @param {string} name key in map
 	 * @param {AsArray<T>} args args for the hook
-	 * @returns {R} result of hook
+	 * @returns {R | undefined} result of hook
 	 */
 	callHooksForName(hookMap, name, ...args) {
 		return this.callHooksForNameWithFallback(
@@ -2965,7 +3501,7 @@ class JavascriptParser extends Parser {
 	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks that should be called
 	 * @param {ExportedVariableInfo} info variable info
 	 * @param  {AsArray<T>} args args for the hook
-	 * @returns {R} result of hook
+	 * @returns {R | undefined} result of hook
 	 */
 	callHooksForInfo(hookMap, info, ...args) {
 		return this.callHooksForInfoWithFallback(
@@ -2982,10 +3518,10 @@ class JavascriptParser extends Parser {
 	 * @template R
 	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks the should be called
 	 * @param {ExportedVariableInfo} info variable info
-	 * @param {function(string): any} fallback callback when variable in not handled by hooks
-	 * @param {function(): any} defined callback when variable is defined
+	 * @param {(function(string): any) | undefined} fallback callback when variable in not handled by hooks
+	 * @param {(function(): any) | undefined} defined callback when variable is defined
 	 * @param {AsArray<T>} args args for the hook
-	 * @returns {R} result of hook
+	 * @returns {R | undefined} result of hook
 	 */
 	callHooksForInfoWithFallback(hookMap, info, fallback, defined, ...args) {
 		let name;
@@ -3032,10 +3568,10 @@ class JavascriptParser extends Parser {
 	 * @template R
 	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks the should be called
 	 * @param {string} name key in map
-	 * @param {function(string): any} fallback callback when variable in not handled by hooks
-	 * @param {function(): any} defined callback when variable is defined
+	 * @param {(function(string): any) | undefined} fallback callback when variable in not handled by hooks
+	 * @param {(function(): any) | undefined} defined callback when variable is defined
 	 * @param {AsArray<T>} args args for the hook
-	 * @returns {R} result of hook
+	 * @returns {R | undefined} result of hook
 	 */
 	callHooksForNameWithFallback(hookMap, name, fallback, defined, ...args) {
 		return this.callHooksForInfoWithFallback(
@@ -3059,6 +3595,7 @@ class JavascriptParser extends Parser {
 			topLevelScope: oldScope.topLevelScope,
 			inTry: false,
 			inShorthand: false,
+			inTaggedTemplateTag: false,
 			isStrict: oldScope.isStrict,
 			isAsmJs: oldScope.isAsmJs,
 			definitions: oldScope.definitions.createChild()
@@ -3075,12 +3612,50 @@ class JavascriptParser extends Parser {
 		this.scope = oldScope;
 	}
 
+	/**
+	 * @param {boolean} hasThis true, when this is defined
+	 * @param {any} params scope params
+	 * @param {function(): void} fn inner function
+	 * @returns {void}
+	 */
+	inClassScope(hasThis, params, fn) {
+		const oldScope = this.scope;
+		this.scope = {
+			topLevelScope: oldScope.topLevelScope,
+			inTry: false,
+			inShorthand: false,
+			inTaggedTemplateTag: 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;
+	}
+
+	/**
+	 * @param {boolean} hasThis true, when this is defined
+	 * @param {any} params scope params
+	 * @param {function(): void} fn inner function
+	 * @returns {void}
+	 */
 	inFunctionScope(hasThis, params, fn) {
 		const oldScope = this.scope;
 		this.scope = {
 			topLevelScope: oldScope.topLevelScope,
 			inTry: false,
 			inShorthand: false,
+			inTaggedTemplateTag: false,
 			isStrict: oldScope.isStrict,
 			isAsmJs: oldScope.isAsmJs,
 			definitions: oldScope.definitions.createChild()
@@ -3099,12 +3674,17 @@ class JavascriptParser extends Parser {
 		this.scope = oldScope;
 	}
 
+	/**
+	 * @param {function(): void} fn inner function
+	 * @returns {void}
+	 */
 	inBlockScope(fn) {
 		const oldScope = this.scope;
 		this.scope = {
 			topLevelScope: oldScope.topLevelScope,
 			inTry: oldScope.inTry,
 			inShorthand: false,
+			inTaggedTemplateTag: false,
 			isStrict: oldScope.isStrict,
 			isAsmJs: oldScope.isAsmJs,
 			definitions: oldScope.definitions.createChild()
@@ -3115,15 +3695,28 @@ class JavascriptParser extends Parser {
 		this.scope = oldScope;
 	}
 
+	/**
+	 * @param {Array<Directive | Statement | ModuleDeclaration>} statements statements
+	 */
 	detectMode(statements) {
 		const isLiteral =
 			statements.length >= 1 &&
 			statements[0].type === "ExpressionStatement" &&
 			statements[0].expression.type === "Literal";
-		if (isLiteral && statements[0].expression.value === "use strict") {
+		if (
+			isLiteral &&
+			/** @type {Literal} */
+			(/** @type {ExpressionStatement} */ (statements[0]).expression).value ===
+				"use strict"
+		) {
 			this.scope.isStrict = true;
 		}
-		if (isLiteral && statements[0].expression.value === "use asm") {
+		if (
+			isLiteral &&
+			/** @type {Literal} */
+			(/** @type {ExpressionStatement} */ (statements[0]).expression).value ===
+				"use asm"
+		) {
 			this.scope.isAsmJs = true;
 		}
 	}
@@ -3168,12 +3761,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;
@@ -3185,6 +3786,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;
@@ -3192,20 +3797,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 {TODO} expression expression node
 	 * @returns {BasicEvaluatedExpression} evaluation result
 	 */
 	evaluateExpression(expression) {
@@ -3223,10 +3837,14 @@ class JavascriptParser extends Parser {
 			// ignore error
 		}
 		return new BasicEvaluatedExpression()
-			.setRange(expression.range)
+			.setRange(/** @type {Range} */ (expression.range))
 			.setExpression(expression);
 	}
 
+	/**
+	 * @param {Expression} expression expression
+	 * @returns {string} parsed string
+	 */
 	parseString(expression) {
 		switch (expression.type) {
 			case "BinaryExpression":
@@ -3335,7 +3953,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 = [];
@@ -3356,6 +3974,7 @@ class JavascriptParser extends Parser {
 			topLevelScope: true,
 			inTry: false,
 			inShorthand: false,
+			inTaggedTemplateTag: false,
 			isStrict: false,
 			isAsmJs: false,
 			definitions: new StackedMap()
@@ -3367,12 +3986,14 @@ class JavascriptParser extends Parser {
 		this.statementPath = [];
 		this.prevStatement = undefined;
 		if (this.hooks.program.call(ast, comments) === undefined) {
+			this.destructuringAssignmentProperties = new WeakMap();
 			this.detectMode(ast.body);
 			this.preWalkStatements(ast.body);
 			this.prevStatement = undefined;
 			this.blockPreWalkStatements(ast.body);
 			this.prevStatement = undefined;
 			this.walkStatements(ast.body);
+			this.destructuringAssignmentProperties = undefined;
 		}
 		this.hooks.finish.call(ast, comments);
 		this.scope = oldScope;
@@ -3401,7 +4022,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
 	 */
@@ -3412,6 +4033,7 @@ class JavascriptParser extends Parser {
 			.call(expr, commentsStartPos);
 		if (typeof result === "boolean") return result;
 		switch (expr.type) {
+			// TODO handle more cases
 			case "ClassDeclaration":
 			case "ClassExpression": {
 				if (expr.body.type !== "ClassBody") return false;
@@ -3419,63 +4041,94 @@ 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":
 			case "FunctionExpression":
 			case "ArrowFunctionExpression":
+			case "ThisExpression":
 			case "Literal":
+			case "TemplateLiteral":
+			case "Identifier":
 			case "PrivateIdentifier":
 				return true;
 
 			case "VariableDeclaration":
 				return expr.declarations.every(decl =>
-					this.isPure(decl.init, decl.range[0])
+					this.isPure(decl.init, /** @type {Range} */ (decl.range)[0])
 				);
 
 			case "ConditionalExpression":
 				return (
 					this.isPure(expr.test, commentsStartPos) &&
-					this.isPure(expr.consequent, expr.test.range[1]) &&
-					this.isPure(expr.alternate, expr.consequent.range[1])
+					this.isPure(
+						expr.consequent,
+						/** @type {Range} */ (expr.test.range)[1]
+					) &&
+					this.isPure(
+						expr.alternate,
+						/** @type {Range} */ (expr.consequent.range)[1]
+					)
+				);
+
+			case "LogicalExpression":
+				return (
+					this.isPure(expr.left, commentsStartPos) &&
+					this.isPure(expr.right, /** @type {Range} */ (expr.left.range)[1])
 				);
 
 			case "SequenceExpression":
 				return expr.expressions.every(expr => {
 					const pureFlag = this.isPure(expr, commentsStartPos);
-					commentsStartPos = expr.range[1];
+					commentsStartPos = /** @type {Range} */ (expr.range)[1];
 					return pureFlag;
 				});
 
 			case "CallExpression": {
 				const pureFlag =
-					expr.range[0] - commentsStartPos > 12 &&
-					this.getComments([commentsStartPos, expr.range[0]]).some(
+					/** @type {Range} */ (expr.range)[0] - commentsStartPos > 12 &&
+					this.getComments([
+						commentsStartPos,
+						/** @type {Range} */ (expr.range)[0]
+					]).some(
 						comment =>
 							comment.type === "Block" &&
 							/^\s*(#|@)__PURE__\s*$/.test(comment.value)
 					);
 				if (!pureFlag) return false;
-				commentsStartPos = expr.callee.range[1];
+				commentsStartPos = /** @type {Range} */ (expr.callee.range)[1];
 				return expr.arguments.every(arg => {
 					if (arg.type === "SpreadElement") return false;
 					const pureFlag = this.isPure(arg, commentsStartPos);
-					commentsStartPos = arg.range[1];
+					commentsStartPos = /** @type {Range} */ (arg.range)[1];
 					return pureFlag;
 				});
 			}
@@ -3484,6 +4137,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;
@@ -3525,6 +4182,10 @@ class JavascriptParser extends Parser {
 		this.semicolons.delete(pos);
 	}
 
+	/**
+	 * @param {Expression} expr expression
+	 * @returns {boolean} true, when the expression is a statement level expression
+	 */
 	isStatementLevelExpression(expr) {
 		const currentStatement = this.statementPath[this.statementPath.length - 1];
 		return (
@@ -3571,6 +4232,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
@@ -3579,10 +4243,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;
@@ -3625,10 +4296,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) {
@@ -3663,21 +4342,24 @@ 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[], memberRanges: Range[] }} member names (reverse order) and remaining object
 	 */
 	extractMemberExpressionChain(expression) {
 		/** @type {AnyNode} */
 		let expr = expression;
 		const members = [];
 		const membersOptionals = [];
+		const memberRanges = [];
 		while (expr.type === "MemberExpression") {
 			if (expr.computed) {
 				if (expr.property.type !== "Literal") break;
-				members.push(`${expr.property.value}`);
+				members.push(`${expr.property.value}`); // the literal
+				memberRanges.push(expr.object.range); // the range of the expression fragment before the literal
 			} else {
 				if (expr.property.type !== "Identifier") break;
-				members.push(expr.property.name);
+				members.push(expr.property.name); // the identifier
+				memberRanges.push(expr.object.range); // the range of the expression fragment before the identifier
 			}
 			membersOptionals.push(expr.optional);
 			expr = expr.object;
@@ -3686,13 +4368,14 @@ class JavascriptParser extends Parser {
 		return {
 			members,
 			membersOptionals,
+			memberRanges,
 			object: expr
 		};
 	}
 
 	/**
 	 * @param {string} varName variable name
-	 * @returns {{name: string, info: VariableInfo | string}} name of the free variable and variable info for that
+	 * @returns {{name: string, info: VariableInfo | string} | undefined} name of the free variable and variable info for that
 	 */
 	getFreeInfoFromVariable(varName) {
 		const info = this.getVariableInfo(varName);
@@ -3708,16 +4391,16 @@ 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: "expression", rootInfo: string | VariableInfo, name: string, getMembers: () => string[], getMembersOptionals: () => boolean[]}} ExpressionExpressionInfo */
+	/** @typedef {{ type: "call", call: CallExpression, calleeName: string, rootInfo: string | VariableInfo, getCalleeMembers: () => string[], name: string, getMembers: () => string[], getMembersOptionals: () => boolean[], getMemberRanges: () => Range[]}} CallExpressionInfo */
+	/** @typedef {{ type: "expression", rootInfo: string | VariableInfo, name: string, getMembers: () => string[], getMembersOptionals: () => boolean[], getMemberRanges: () => Range[]}} 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
 	 */
 	getMemberExpressionInfo(expression, allowedTypes) {
-		const { object, members, membersOptionals } =
+		const { object, members, membersOptionals, memberRanges } =
 			this.extractMemberExpressionChain(expression);
 		switch (object.type) {
 			case "CallExpression": {
@@ -3743,7 +4426,8 @@ class JavascriptParser extends Parser {
 					getCalleeMembers: memoize(() => rootMembers.reverse()),
 					name: objectAndMembersToName(`${calleeName}()`, members),
 					getMembers: memoize(() => members.reverse()),
-					getMembersOptionals: memoize(() => membersOptionals.reverse())
+					getMembersOptionals: memoize(() => membersOptionals.reverse()),
+					getMemberRanges: memoize(() => memberRanges.reverse())
 				};
 			}
 			case "Identifier":
@@ -3762,15 +4446,16 @@ class JavascriptParser extends Parser {
 					name: objectAndMembersToName(resolvedRoot, members),
 					rootInfo,
 					getMembers: memoize(() => members.reverse()),
-					getMembersOptionals: memoize(() => membersOptionals.reverse())
+					getMembersOptionals: memoize(() => membersOptionals.reverse()),
+					getMemberRanges: memoize(() => memberRanges.reverse())
 				};
 			}
 		}
 	}
 
 	/**
-	 * @param {MemberExpressionNode} expression an expression
-	 * @returns {{ name: string, rootInfo: ExportedVariableInfo, getMembers: () => string[]}} name info
+	 * @param {MemberExpression} expression an expression
+	 * @returns {{ name: string, rootInfo: ExportedVariableInfo, getMembers: () => string[]} | undefined} name info
 	 */
 	getNameForExpression(expression) {
 		return this.getMemberExpressionInfo(
@@ -3782,7 +4467,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";
@@ -3794,7 +4479,7 @@ class JavascriptParser extends Parser {
 			sourceType: type === "auto" ? "module" : type
 		};
 
-		/** @type {AnyNode} */
+		/** @type {AnyNode | undefined} */
 		let ast;
 		let error;
 		let threw = false;
@@ -3826,7 +4511,7 @@ class JavascriptParser extends Parser {
 			throw error;
 		}
 
-		return /** @type {ProgramNode} */ (ast);
+		return /** @type {Program} */ (ast);
 	}
 }