webpack 5.59.0 → 5.94.0

package/lib/javascript/JavascriptParser.js

@@ -6,7 +6,7 @@
 "use strict";
 
 const { Parser: AcornParser } = require("acorn");
-const { importAssertions } = require("acorn-import-assertions");
+const { importAttributesOrAssertions } = require("acorn-import-attributes");
 const { SyncBailHook, HookMap } = require("tapable");
 const vm = require("vm");
 const Parser = require("../Parser");
@@ -16,49 +16,92 @@ 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 */
-/** @template T @typedef {import("tapable").AsArray<T>} AsArray<T> */
+/** @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 {import("estree").AssignmentProperty} AssignmentProperty */
+/**
+ * @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[] }} GetInfoResult */
+/** @typedef {{ name: string | VariableInfo, rootInfo: string | VariableInfo, getMembers: () => string[], getMembersOptionals: () => boolean[], getMemberRanges: () => Range[] }} GetInfoResult */
+/** @typedef {Statement | ModuleDeclaration | Expression} StatementPathItem */
+/** @typedef {TODO} OnIdent */
 
+/** @typedef {Record<string, string> & { _isLegacyAssert?: boolean }} ImportAttributes */
+
+/** @type {string[]} */
 const EMPTY_ARRAY = [];
 const ALLOWED_MEMBER_TYPES_CALL_EXPRESSION = 0b01;
 const ALLOWED_MEMBER_TYPES_EXPRESSION = 0b10;
@@ -66,12 +109,12 @@ const ALLOWED_MEMBER_TYPES_ALL = 0b11;
 
 // Syntax: https://developer.mozilla.org/en/SpiderMonkey/Parser_API
 
-const parser = AcornParser.extend(importAssertions);
+const parser = AcornParser.extend(importAttributesOrAssertions);
 
 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,40 +125,88 @@ 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 */
 
 /**
- * @typedef {Object} TagInfo
+ * @typedef {object} TagInfo
  * @property {any} tag
  * @property {any} data
  * @property {TagInfo | undefined} next
  */
 
 /**
- * @typedef {Object} ScopeInfo
+ * @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 */
+
+/**
+ * @typedef {object} DestructuringAssignmentProperty
+ * @property {string} id
+ * @property {Range | undefined=} range
+ * @property {boolean | string} shorthand
+ */
+
+/**
+ * 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--) {
-		name = name + "." + membersReversed[i];
+		name = `${name}.${membersReversed[i]}`;
 	}
 	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 | SpreadElement | Super} expression expression
+ * @returns {string | "this" | undefined} name or variable info
+ */
 const getRootName = expression => {
 	switch (expression.type) {
 		case "Identifier":
@@ -155,73 +246,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 | SpreadElement], 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<[CallExpressionNode, BasicEvaluatedExpression | undefined], BasicEvaluatedExpression | undefined | null>>} */
+			/** @type {HookMap<SyncBailHook<[NewExpression], BasicEvaluatedExpression | undefined | null>>} */
+			evaluateNewExpression: new HookMap(
+				() => new SyncBailHook(["expression"])
+			),
+			/** @type {HookMap<SyncBailHook<[CallExpression], BasicEvaluatedExpression | undefined | null>>} */
+			evaluateCallExpression: new HookMap(
+				() => new SyncBailHook(["expression"])
+			),
+			/** @type {HookMap<SyncBailHook<[CallExpression, BasicEvaluatedExpression], 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<[ExportDefaultDeclaration | ExportNamedDeclaration], 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<[ExportDefaultDeclaration | ExportNamedDeclaration | ExportAllDeclaration, Declaration], boolean | void>} */
 			exportDeclaration: new SyncBailHook(["statement", "declaration"]),
-			/** @type {SyncBailHook<[ExportDefaultDeclarationNode, DeclarationNode], boolean | void>} */
+			/** @type {SyncBailHook<[ExportDefaultDeclaration, FunctionDeclaration | ClassDeclaration], boolean | void>} */
 			exportExpression: new SyncBailHook(["statement", "declaration"]),
-			/** @type {SyncBailHook<[ExportNamedDeclarationNode | ExportAllDeclarationNode, string, string, number | undefined], boolean | void>} */
+			/** @type {SyncBailHook<[ExportDefaultDeclaration | 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",
@@ -229,86 +328,102 @@ 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 | ForOfStatement], 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 | void>>} */
+			/** @type {HookMap<SyncBailHook<[CallExpression, string[], boolean[], Range[]], boolean | void>>} */
 			callMemberChain: new HookMap(
-				() => new SyncBailHook(["expression", "members"])
+				() =>
+					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[], Range[]], boolean | void>>} */
 			memberChainOfCallMemberChain: new HookMap(
 				() =>
 					new SyncBailHook([
 						"expression",
 						"calleeMembers",
 						"callExpression",
-						"members"
+						"members",
+						"memberRanges"
 					])
 			),
 			/** Something like "a.b().c.d()"" */
-			/** @type {HookMap<SyncBailHook<[ExpressionNode, string[], CallExpressionNode, string[]], boolean | void>>} */
+			/** @type {HookMap<SyncBailHook<[CallExpression, string[], CallExpression, string[], Range[]], boolean | void>>} */
 			callMemberChainOfCallMemberChain: new HookMap(
 				() =>
 					new SyncBailHook([
 						"expression",
 						"calleeMembers",
 						"innerCallExpression",
-						"members"
+						"members",
+						"memberRanges"
 					])
 			),
-			/** @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 {HookMap<SyncBailHook<[ExpressionNode], boolean | void>>} */
+			/** @type {SyncBailHook<[BinaryExpression], boolean | void>} */
+			binaryExpression: new SyncBailHook(["binaryExpression"]),
+			/** @type {HookMap<SyncBailHook<[Expression], boolean | void>>} */
 			expression: new HookMap(() => new SyncBailHook(["expression"])),
-			/** @type {HookMap<SyncBailHook<[ExpressionNode, string[]], boolean | void>>} */
+			/** @type {HookMap<SyncBailHook<[MemberExpression, string[], boolean[], Range[]], boolean | void>>} */
 			expressionMemberChain: new HookMap(
-				() => new SyncBailHook(["expression", "members"])
+				() =>
+					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;
@@ -316,58 +431,74 @@ class JavascriptParser extends Parser {
 		this.scope = undefined;
 		/** @type {ParserState} */
 		this.state = undefined;
+		/** @type {Comment[] | undefined} */
 		this.comments = undefined;
+		/** @type {Set<number> | undefined} */
 		this.semicolons = undefined;
-		/** @type {(StatementNode|ExpressionNode)[]} */
+		/** @type {StatementPathItem[]} */
 		this.statementPath = undefined;
+		/** @type {Statement | ModuleDeclaration | Expression | undefined} */
 		this.prevStatement = undefined;
+		/** @type {WeakMap<Expression, Set<DestructuringAssignmentProperty>> | undefined} */
+		this.destructuringAssignmentProperties = undefined;
 		this.currentTagData = undefined;
+		this.magicCommentContext = vm.createContext(undefined, {
+			name: "Webpack Magic Comment Parser",
+			codeGeneration: { strings: false, wasm: false }
+		});
 		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" ||
-				callee.name !== "RegExp" ||
+			if (callee.type !== "Identifier") return;
+			if (callee.name !== "RegExp") {
+				return this.callHooksForName(
+					this.hooks.evaluateNewExpression,
+					callee.name,
+					expr
+				);
+			} else if (
 				expr.arguments.length > 2 ||
 				this.getVariableInfo("RegExp") !== "RegExp"
 			)
 				return;
 
-			let regExp, flags;
+			let regExp;
 			const arg1 = expr.arguments[0];
 
 			if (arg1) {
@@ -381,11 +512,15 @@ class JavascriptParser extends Parser {
 
 				if (!regExp) return;
 			} else {
-				return new BasicEvaluatedExpression()
-					.setRegExp(new RegExp(""))
-					.setRange(expr.range);
+				return (
+					new BasicEvaluatedExpression()
+						// eslint-disable-next-line prefer-regex-literals
+						.setRegExp(new RegExp(""))
+						.setRange(/** @type {Range} */ (expr.range))
+				);
 			}
 
+			let flags;
 			const arg2 = expr.arguments[1];
 
 			if (arg2) {
@@ -408,90 +543,142 @@ 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);
-				if (!left) return;
 				let returnRight = false;
 				/** @type {boolean|undefined} */
 				let allowedRight;
 				if (expr.operator === "&&") {
 					const leftAsBool = left.asBool();
-					if (leftAsBool === false) return left.setRange(expr.range);
+					if (leftAsBool === false)
+						return left.setRange(/** @type {Range} */ (expr.range));
 					returnRight = leftAsBool === true;
 					allowedRight = false;
 				} else if (expr.operator === "||") {
 					const leftAsBool = left.asBool();
-					if (leftAsBool === true) return left.setRange(expr.range);
+					if (leftAsBool === true)
+						return left.setRange(/** @type {Range} */ (expr.range));
 					returnRight = leftAsBool === false;
 					allowedRight = true;
 				} else if (expr.operator === "??") {
 					const leftAsNullish = left.asNullish();
-					if (leftAsNullish === false) return left.setRange(expr.range);
+					if (leftAsNullish === false)
+						return left.setRange(/** @type {Range} */ (expr.range));
 					if (leftAsNullish !== true) return;
 					returnRight = true;
 				} else return;
 				const right = this.evaluateExpression(expr.right);
-				if (!right) return;
 				if (returnRight) {
 					if (left.couldHaveSideEffects()) right.setSideEffects();
-					return right.setRange(expr.range);
+					return right.setRange(/** @type {Range} */ (expr.range));
 				}
 
 				const asBool = right.asBool();
 
 				if (allowedRight === true && asBool === true) {
 					return new BasicEvaluatedExpression()
-						.setRange(expr.range)
+						.setRange(/** @type {Range} */ (expr.range))
 						.setTruthy();
 				} else if (allowedRight === false && asBool === false) {
-					return new BasicEvaluatedExpression().setRange(expr.range).setFalsy();
+					return new BasicEvaluatedExpression()
+						.setRange(/** @type {Range} */ (expr.range))
+						.setFalsy();
 				}
 			});
 
+		/**
+		 * 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 || !left.isCompileTimeValue()) return;
+					if (!left.isCompileTimeValue()) return;
 
 					const right = this.evaluateExpression(expr.right);
-					if (!right || !right.isCompileTimeValue()) return;
+					if (!right.isCompileTimeValue()) return;
 
-					const result = fn(
+					const result = operandHandler(
 						left.asCompileTimeValue(),
 						right.asCompileTimeValue()
 					);
@@ -502,10 +689,28 @@ 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);
 
+				/**
+				 * @param {BasicEvaluatedExpression} left left
+				 * @param {BasicEvaluatedExpression} right right
+				 * @param {BasicEvaluatedExpression} res res
+				 * @param {boolean} eql true for "===" and false for "!=="
+				 * @returns {BasicEvaluatedExpression | undefined} result
+				 */
 				const handleTemplateStringCompare = (left, right, res, eql) => {
+					/**
+					 * @param {BasicEvaluatedExpression[]} parts parts
+					 * @returns {string} value
+					 */
 					const getPrefix = parts => {
 						let value = "";
 						for (const p of parts) {
@@ -515,6 +720,10 @@ class JavascriptParser extends Parser {
 						}
 						return value;
 					};
+					/**
+					 * @param {BasicEvaluatedExpression[]} parts parts
+					 * @returns {string} value
+					 */
 					const getSuffix = parts => {
 						let value = "";
 						for (let i = parts.length - 1; i >= 0; i--) {
@@ -524,17 +733,27 @@ class JavascriptParser extends Parser {
 						}
 						return value;
 					};
-					const leftPrefix = getPrefix(left.parts);
-					const rightPrefix = getPrefix(right.parts);
-					const leftSuffix = getSuffix(left.parts);
-					const rightSuffix = getSuffix(right.parts);
+					const leftPrefix = getPrefix(
+						/** @type {BasicEvaluatedExpression[]} */ (left.parts)
+					);
+					const rightPrefix = getPrefix(
+						/** @type {BasicEvaluatedExpression[]} */ (right.parts)
+					);
+					const leftSuffix = getSuffix(
+						/** @type {BasicEvaluatedExpression[]} */ (left.parts)
+					);
+					const rightSuffix = getSuffix(
+						/** @type {BasicEvaluatedExpression[]} */ (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(
@@ -543,13 +762,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);
-					if (!left) return;
 					const right = this.evaluateExpression(expr.right);
-					if (!right) return;
 					const res = new BasicEvaluatedExpression();
-					res.setRange(expr.range);
+					res.setRange(/** @type {Range} */ (expr.range));
 
 					const leftConst = left.isCompileTimeValue();
 					const rightConst = right.isCompileTimeValue();
@@ -587,8 +809,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)
@@ -598,13 +826,16 @@ 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);
-					if (!left) return;
 					const right = this.evaluateExpression(expr.right);
-					if (!right) return;
 					const res = new BasicEvaluatedExpression();
-					res.setRange(expr.range);
+					res.setRange(/** @type {Range} */ (expr.range));
 
 					const leftConst = left.isCompileTimeValue();
 					const rightConst = right.isCompileTimeValue();
@@ -635,15 +866,16 @@ class JavascriptParser extends Parser {
 
 				if (expr.operator === "+") {
 					const left = this.evaluateExpression(expr.left);
-					if (!left) return;
 					const right = this.evaluateExpression(expr.right);
-					if (!right) return;
 					const res = new BasicEvaluatedExpression();
 					if (left.isString()) {
 						if (right.isString()) {
-							res.setString(left.string + right.string);
+							res.setString(
+								/** @type {string} */ (left.string) +
+									/** @type {string} */ (right.string)
+							);
 						} else if (right.isNumber()) {
-							res.setString(left.string + right.number);
+							res.setString(/** @type {string} */ (left.string) + right.number);
 						} else if (
 							right.isWrapped() &&
 							right.prefix &&
@@ -653,8 +885,16 @@ class JavascriptParser extends Parser {
 							// => ("leftPrefix" + inner + "postfix")
 							res.setWrapped(
 								new BasicEvaluatedExpression()
-									.setString(left.string + right.prefix.string)
-									.setRange(joinRanges(left.range, right.prefix.range)),
+									.setString(
+										/** @type {string} */ (left.string) +
+											/** @type {string} */ (right.prefix.string)
+									)
+									.setRange(
+										joinRanges(
+											/** @type {Range} */ (left.range),
+											/** @type {Range} */ (right.prefix.range)
+										)
+									),
 								right.postfix,
 								right.wrappedInnerExpressions
 							);
@@ -673,15 +913,21 @@ class JavascriptParser extends Parser {
 						}
 					} else if (left.isNumber()) {
 						if (right.isString()) {
-							res.setString(left.number + right.string);
+							res.setString(left.number + /** @type {string} */ (right.string));
 						} else if (right.isNumber()) {
-							res.setNumber(left.number + right.number);
+							res.setNumber(
+								/** @type {number} */ (left.number) +
+									/** @type {number} */ (right.number)
+							);
 						} else {
 							return;
 						}
 					} else if (left.isBigInt()) {
 						if (right.isBigInt()) {
-							res.setBigInt(left.bigint + right.bigint);
+							res.setBigInt(
+								/** @type {bigint} */ (left.bigint) +
+									/** @type {bigint} */ (right.bigint)
+							);
 						}
 					} else if (left.isWrapped()) {
 						if (left.postfix && left.postfix.isString() && right.isString()) {
@@ -690,8 +936,16 @@ class JavascriptParser extends Parser {
 							res.setWrapped(
 								left.prefix,
 								new BasicEvaluatedExpression()
-									.setString(left.postfix.string + right.string)
-									.setRange(joinRanges(left.postfix.range, right.range)),
+									.setString(
+										/** @type {string} */ (left.postfix.string) +
+											/** @type {string} */ (right.string)
+									)
+									.setRange(
+										joinRanges(
+											/** @type {Range} */ (left.postfix.range),
+											/** @type {Range} */ (right.range)
+										)
+									),
 								left.wrappedInnerExpressions
 							);
 						} else if (
@@ -704,8 +958,16 @@ class JavascriptParser extends Parser {
 							res.setWrapped(
 								left.prefix,
 								new BasicEvaluatedExpression()
-									.setString(left.postfix.string + right.number)
-									.setRange(joinRanges(left.postfix.range, right.range)),
+									.setString(
+										/** @type {string} */ (left.postfix.string) +
+											/** @type {number} */ (right.number)
+									)
+									.setRange(
+										joinRanges(
+											/** @type {Range} */ (left.postfix.range),
+											/** @type {Range} */ (right.range)
+										)
+									),
 								left.wrappedInnerExpressions
 							);
 						} else if (right.isString()) {
@@ -718,8 +980,8 @@ class JavascriptParser extends Parser {
 							res.setWrapped(
 								left.prefix,
 								new BasicEvaluatedExpression()
-									.setString(right.number + "")
-									.setRange(right.range),
+									.setString(String(right.number))
+									.setRange(/** @type {Range} */ (right.range)),
 								left.wrappedInnerExpressions
 							);
 						} else if (right.isWrapped()) {
@@ -747,29 +1009,27 @@ class JavascriptParser extends Parser {
 									)
 							);
 						}
+					} else if (right.isString()) {
+						// left + "right"
+						// => ([null] + left + "right")
+						res.setWrapped(null, right, [left]);
+					} else if (right.isWrapped()) {
+						// left + (prefix + inner + "postfix")
+						// => ([null] + left + prefix + inner + "postfix")
+						res.setWrapped(
+							null,
+							right.postfix,
+							right.wrappedInnerExpressions &&
+								(right.prefix ? [left, right.prefix] : [left]).concat(
+									right.wrappedInnerExpressions
+								)
+						);
 					} else {
-						if (right.isString()) {
-							// left + "right"
-							// => ([null] + left + "right")
-							res.setWrapped(null, right, [left]);
-						} else if (right.isWrapped()) {
-							// left + (prefix + inner + "postfix")
-							// => ([null] + left + prefix + inner + "postfix")
-							res.setWrapped(
-								null,
-								right.postfix,
-								right.wrappedInnerExpressions &&
-									(right.prefix ? [left, right.prefix] : [left]).concat(
-										right.wrappedInnerExpressions
-									)
-							);
-						} else {
-							return;
-						}
+						return;
 					}
 					if (left.couldHaveSideEffects() || right.couldHaveSideEffects())
 						res.setSideEffects();
-					res.setRange(expr.range);
+					res.setRange(/** @type {Range} */ (expr.range));
 					return res;
 				} else if (expr.operator === "-") {
 					return handleConstOperation((l, r) => l - r);
@@ -812,12 +1072,18 @@ 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 || !argument.isCompileTimeValue()) return;
-					const result = fn(argument.asCompileTimeValue());
+					if (!argument.isCompileTimeValue()) return;
+					const result = operandHandler(argument.asCompileTimeValue());
 					return valueAsExpression(
 						result,
 						expr,
@@ -866,7 +1132,7 @@ class JavascriptParser extends Parser {
 						case "FunctionExpression": {
 							return new BasicEvaluatedExpression()
 								.setString("function")
-								.setRange(expr.range);
+								.setRange(/** @type {Range} */ (expr.range));
 						}
 					}
 					const arg = this.evaluateExpression(expr.argument);
@@ -874,79 +1140,88 @@ class JavascriptParser extends Parser {
 					if (arg.isString()) {
 						return new BasicEvaluatedExpression()
 							.setString("string")
-							.setRange(expr.range);
+							.setRange(/** @type {Range} */ (expr.range));
 					}
 					if (arg.isWrapped()) {
 						return new BasicEvaluatedExpression()
 							.setString("string")
 							.setSideEffects()
-							.setRange(expr.range);
+							.setRange(/** @type {Range} */ (expr.range));
 					}
 					if (arg.isUndefined()) {
 						return new BasicEvaluatedExpression()
 							.setString("undefined")
-							.setRange(expr.range);
+							.setRange(/** @type {Range} */ (expr.range));
 					}
 					if (arg.isNumber()) {
 						return new BasicEvaluatedExpression()
 							.setString("number")
-							.setRange(expr.range);
+							.setRange(/** @type {Range} */ (expr.range));
 					}
 					if (arg.isBigInt()) {
 						return new BasicEvaluatedExpression()
 							.setString("bigint")
-							.setRange(expr.range);
+							.setRange(/** @type {Range} */ (expr.range));
 					}
 					if (arg.isBoolean()) {
 						return new BasicEvaluatedExpression()
 							.setString("boolean")
-							.setRange(expr.range);
+							.setRange(/** @type {Range} */ (expr.range));
 					}
 					if (arg.isConstArray() || arg.isRegExp() || arg.isNull()) {
 						return new BasicEvaluatedExpression()
 							.setString("object")
-							.setRange(expr.range);
+							.setRange(/** @type {Range} */ (expr.range));
 					}
 					if (arg.isArray()) {
 						return new BasicEvaluatedExpression()
 							.setString("object")
 							.setSideEffects(arg.couldHaveSideEffects())
-							.setRange(expr.range);
+							.setRange(/** @type {Range} */ (expr.range));
 					}
 				} else if (expr.operator === "!") {
 					const argument = this.evaluateExpression(expr.argument);
-					if (!argument) return;
 					const bool = argument.asBool();
 					if (typeof bool !== "boolean") return;
 					return new BasicEvaluatedExpression()
 						.setBoolean(!bool)
 						.setSideEffects(argument.couldHaveSideEffects())
-						.setRange(expr.range);
+						.setRange(/** @type {Range} */ (expr.range));
 				} else if (expr.operator === "~") {
 					return handleConstOperation(v => ~v);
 				} else if (expr.operator === "+") {
+					// eslint-disable-next-line no-implicit-coercion
 					return handleConstOperation(v => +v);
 				} else if (expr.operator === "-") {
 					return handleConstOperation(v => -v);
 				}
 			});
-		this.hooks.evaluateTypeof.for("undefined").tap("JavascriptParser", expr => {
-			return new BasicEvaluatedExpression()
-				.setString("undefined")
-				.setRange(expr.range);
+		this.hooks.evaluateTypeof
+			.for("undefined")
+			.tap("JavascriptParser", expr =>
+				new BasicEvaluatedExpression()
+					.setString("undefined")
+					.setRange(/** @type {Range} */ (expr.range))
+			);
+		this.hooks.evaluate.for("Identifier").tap("JavascriptParser", expr => {
+			if (/** @type {Identifier} */ (expr).name === "undefined") {
+				return new BasicEvaluatedExpression()
+					.setUndefined()
+					.setRange(/** @type {Range} */ (expr.range));
+			}
 		});
 		/**
 		 * @param {string} exprType expression type name
-		 * @param {function(ExpressionNode): GetInfoResult | undefined} getInfo get info
+		 * @param {function(Expression | SpreadElement): GetInfoResult | undefined} getInfo get info
 		 * @returns {void}
 		 */
 		const tapEvaluateWithVariableInfo = (exprType, getInfo) => {
-			/** @type {ExpressionNode | undefined} */
-			let cachedExpression = undefined;
+			/** @type {Expression | undefined} */
+			let cachedExpression;
 			/** @type {GetInfoResult | undefined} */
-			let cachedInfo = undefined;
+			let cachedInfo;
 			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) {
@@ -973,8 +1248,14 @@ class JavascriptParser extends Parser {
 					const info = cachedExpression === expr ? cachedInfo : getInfo(expr);
 					if (info !== undefined) {
 						return new BasicEvaluatedExpression()
-							.setIdentifier(info.name, info.rootInfo, info.getMembers)
-							.setRange(expr.range);
+							.setIdentifier(
+								info.name,
+								info.rootInfo,
+								info.getMembers,
+								info.getMembersOptionals,
+								info.getMemberRanges
+							)
+							.setRange(/** @type {Range} */ (expr.range));
 					}
 				});
 			this.hooks.finish.tap("JavascriptParser", () => {
@@ -983,14 +1264,18 @@ 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")
 			) {
-				return { name: info, rootInfo: info, getMembers: () => [] };
+				return {
+					name: info,
+					rootInfo: info,
+					getMembers: () => [],
+					getMembersOptionals: () => [],
+					getMemberRanges: () => []
+				};
 			}
 		});
 		tapEvaluateWithVariableInfo("ThisExpression", expr => {
@@ -999,11 +1284,17 @@ class JavascriptParser extends Parser {
 				typeof info === "string" ||
 				(info instanceof VariableInfo && typeof info.freeName === "string")
 			) {
-				return { name: info, rootInfo: info, getMembers: () => [] };
+				return {
+					name: info,
+					rootInfo: info,
+					getMembers: () => [],
+					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,
@@ -1013,33 +1304,36 @@ 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 !==
+				expr.callee.type === "MemberExpression" &&
+				expr.callee.property.type ===
 					(expr.callee.computed ? "Literal" : "Identifier")
 			) {
-				return;
-			}
-
-			// type Super also possible here
-			const param = this.evaluateExpression(
-				/** @type {ExpressionNode} */ (expr.callee.object)
-			);
-			if (!param) return;
-			const property =
-				expr.callee.property.type === "Literal"
-					? `${expr.callee.property.value}`
-					: expr.callee.property.name;
-			const hook = this.hooks.evaluateCallExpressionMember.get(property);
-			if (hook !== undefined) {
-				return hook.call(expr, param);
+				// type Super also possible here
+				const param = this.evaluateExpression(
+					/** @type {Expression} */ (expr.callee.object)
+				);
+				const property =
+					expr.callee.property.type === "Literal"
+						? `${expr.callee.property.value}`
+						: expr.callee.property.name;
+				const hook = this.hooks.evaluateCallExpressionMember.get(property);
+				if (hook !== undefined) {
+					return hook.call(expr, param);
+				}
+			} else if (expr.callee.type === "Identifier") {
+				return this.callHooksForName(
+					this.hooks.evaluateCallExpression,
+					expr.callee.name,
+					expr
+				);
 			}
 		});
 		this.hooks.evaluateCallExpressionMember
@@ -1051,21 +1345,24 @@ class JavascriptParser extends Parser {
 				if (arg1.type === "SpreadElement") return;
 				const arg1Eval = this.evaluateExpression(arg1);
 				if (!arg1Eval.isString()) return;
-				const arg1Value = arg1Eval.string;
+				const arg1Value = /** @type {string} */ (arg1Eval.string);
 
 				let result;
 				if (arg2) {
 					if (arg2.type === "SpreadElement") return;
 					const arg2Eval = this.evaluateExpression(arg2);
 					if (!arg2Eval.isNumber()) return;
-					result = param.string.indexOf(arg1Value, arg2Eval.number);
+					result = /** @type {string} */ (param.string).indexOf(
+						arg1Value,
+						arg2Eval.number
+					);
 				} else {
-					result = param.string.indexOf(arg1Value);
+					result = /** @type {string} */ (param.string).indexOf(arg1Value);
 				}
 				return new BasicEvaluatedExpression()
 					.setNumber(result)
 					.setSideEffects(param.couldHaveSideEffects())
-					.setRange(expr.range);
+					.setRange(/** @type {Range} */ (expr.range));
 			});
 		this.hooks.evaluateCallExpressionMember
 			.for("replace")
@@ -1074,31 +1371,37 @@ class JavascriptParser extends Parser {
 				if (expr.arguments.length !== 2) return;
 				if (expr.arguments[0].type === "SpreadElement") return;
 				if (expr.arguments[1].type === "SpreadElement") return;
-				let arg1 = this.evaluateExpression(expr.arguments[0]);
-				let arg2 = this.evaluateExpression(expr.arguments[1]);
+				const arg1 = this.evaluateExpression(expr.arguments[0]);
+				const arg2 = this.evaluateExpression(expr.arguments[1]);
 				if (!arg1.isString() && !arg1.isRegExp()) return;
-				const arg1Value = arg1.regExp || arg1.string;
+				const arg1Value = /** @type {string | RegExp} */ (
+					arg1.regExp || arg1.string
+				);
 				if (!arg2.isString()) return;
-				const arg2Value = arg2.string;
+				const arg2Value = /** @type {string} */ (arg2.string);
 				return new BasicEvaluatedExpression()
-					.setString(param.string.replace(arg1Value, arg2Value))
+					.setString(
+						/** @type {string} */ (param.string).replace(arg1Value, arg2Value)
+					)
 					.setSideEffects(param.couldHaveSideEffects())
-					.setRange(expr.range);
+					.setRange(/** @type {Range} */ (expr.range));
 			});
-		["substr", "substring", "slice"].forEach(fn => {
+		for (const fn of ["substr", "substring", "slice"]) {
 			this.hooks.evaluateCallExpressionMember
 				.for(fn)
 				.tap("JavascriptParser", (expr, param) => {
 					if (!param.isString()) return;
 					let arg1;
-					let result,
-						str = param.string;
+					let result;
+					const str = /** @type {string} */ (param.string);
 					switch (expr.arguments.length) {
 						case 1:
 							if (expr.arguments[0].type === "SpreadElement") return;
 							arg1 = this.evaluateExpression(expr.arguments[0]);
 							if (!arg1.isNumber()) return;
-							result = str[fn](arg1.number);
+							result = str[
+								/** @type {"substr" | "substring" | "slice"} */ (fn)
+							](/** @type {number} */ (arg1.number));
 							break;
 						case 2: {
 							if (expr.arguments[0].type === "SpreadElement") return;
@@ -1107,7 +1410,12 @@ class JavascriptParser extends Parser {
 							const arg2 = this.evaluateExpression(expr.arguments[1]);
 							if (!arg1.isNumber()) return;
 							if (!arg2.isNumber()) return;
-							result = str[fn](arg1.number, arg2.number);
+							result = str[
+								/** @type {"substr" | "substring" | "slice"} */ (fn)
+							](
+								/** @type {number} */ (arg1.number),
+								/** @type {number} */ (arg2.number)
+							);
 							break;
 						}
 						default:
@@ -1116,13 +1424,13 @@ class JavascriptParser extends Parser {
 					return new BasicEvaluatedExpression()
 						.setString(result)
 						.setSideEffects(param.couldHaveSideEffects())
-						.setRange(expr.range);
+						.setRange(/** @type {Range} */ (expr.range));
 				});
-		});
+		}
 
 		/**
 		 * @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) => {
@@ -1149,7 +1457,10 @@ class JavascriptParser extends Parser {
 						// is a const string
 
 						prevExpr.setString(prevExpr.string + exprAsString + quasi);
-						prevExpr.setRange([prevExpr.range[0], quasiExpr.range[1]]);
+						prevExpr.setRange([
+							/** @type {Range} */ (prevExpr.range)[0],
+							/** @type {Range} */ (quasiExpr.range)[1]
+						]);
 						// We unset the expression as it doesn't match to a single expression
 						prevExpr.setExpression(undefined);
 						continue;
@@ -1158,8 +1469,8 @@ class JavascriptParser extends Parser {
 				}
 
 				const part = new BasicEvaluatedExpression()
-					.setString(quasi)
-					.setRange(quasiExpr.range)
+					.setString(/** @type {string} */ (quasi))
+					.setRange(/** @type {Range} */ (quasiExpr.range))
 					.setExpression(quasiExpr);
 				quasis.push(part);
 				parts.push(part);
@@ -1173,37 +1484,37 @@ 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") return;
-				const { quasis, parts } = getSimplifiedTemplateResult(
-					"raw",
-					node.quasi
-				);
-				return new BasicEvaluatedExpression()
-					.setTemplateString(quasis, parts, "raw")
-					.setRange(node.range);
+				if (tag.isIdentifier() && tag.identifier === "String.raw") {
+					const { quasis, parts } = getSimplifiedTemplateResult(
+						"raw",
+						node.quasi
+					);
+					return new BasicEvaluatedExpression()
+						.setTemplateString(quasis, parts, "raw")
+						.setRange(/** @type {Range} */ (node.range));
+				}
 			});
 
 		this.hooks.evaluateCallExpressionMember
 			.for("concat")
 			.tap("JavascriptParser", (expr, param) => {
 				if (!param.isString() && !param.isWrapped()) return;
-
 				let stringSuffix = null;
 				let hasUnknownParams = false;
 				const innerExpressions = [];
@@ -1220,15 +1531,17 @@ class JavascriptParser extends Parser {
 						continue;
 					}
 
+					/** @type {string} */
 					const value = argExpr.isString()
-						? argExpr.string
-						: "" + argExpr.number;
+						? /** @type {string} */ (argExpr.string)
+						: String(/** @type {number} */ (argExpr.number));
 
+					/** @type {string} */
 					const newString = value + (stringSuffix ? stringSuffix.string : "");
-					const newRange = [
-						argExpr.range[0],
-						(stringSuffix || argExpr).range[1]
-					];
+					const newRange = /** @type {Range} */ ([
+						/** @type {Range} */ (argExpr.range)[0],
+						/** @type {Range} */ ((stringSuffix || argExpr).range)[1]
+					]);
 					stringSuffix = new BasicEvaluatedExpression()
 						.setString(newString)
 						.setSideEffects(
@@ -1246,7 +1559,7 @@ class JavascriptParser extends Parser {
 							: innerExpressions.reverse();
 					return new BasicEvaluatedExpression()
 						.setWrapped(prefix, stringSuffix, inner)
-						.setRange(expr.range);
+						.setRange(/** @type {Range} */ (expr.range));
 				} else if (param.isWrapped()) {
 					const postfix = stringSuffix || param.postfix;
 					const inner = param.wrappedInnerExpressions
@@ -1254,18 +1567,18 @@ class JavascriptParser extends Parser {
 						: innerExpressions.reverse();
 					return new BasicEvaluatedExpression()
 						.setWrapped(param.prefix, postfix, inner)
-						.setRange(expr.range);
-				} else {
-					const newString =
-						param.string + (stringSuffix ? stringSuffix.string : "");
-					return new BasicEvaluatedExpression()
-						.setString(newString)
-						.setSideEffects(
-							(stringSuffix && stringSuffix.couldHaveSideEffects()) ||
-								param.couldHaveSideEffects()
-						)
-						.setRange(expr.range);
+						.setRange(/** @type {Range} */ (expr.range));
 				}
+				const newString =
+					/** @type {string} */ (param.string) +
+					(stringSuffix ? stringSuffix.string : "");
+				return new BasicEvaluatedExpression()
+					.setString(newString)
+					.setSideEffects(
+						(stringSuffix && stringSuffix.couldHaveSideEffects()) ||
+							param.couldHaveSideEffects()
+					)
+					.setRange(/** @type {Range} */ (expr.range));
 			});
 		this.hooks.evaluateCallExpressionMember
 			.for("split")
@@ -1276,21 +1589,25 @@ class JavascriptParser extends Parser {
 				let result;
 				const arg = this.evaluateExpression(expr.arguments[0]);
 				if (arg.isString()) {
-					result = param.string.split(arg.string);
+					result =
+						/** @type {string} */
+						(param.string).split(/** @type {string} */ (arg.string));
 				} else if (arg.isRegExp()) {
-					result = param.string.split(arg.regExp);
+					result = /** @type {string} */ (param.string).split(
+						/** @type {RegExp} */ (arg.regExp)
+					);
 				} else {
 					return;
 				}
 				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();
@@ -1298,15 +1615,18 @@ class JavascriptParser extends Parser {
 				if (conditionValue === undefined) {
 					const consequent = this.evaluateExpression(expr.consequent);
 					const alternate = this.evaluateExpression(expr.alternate);
-					if (!consequent || !alternate) return;
 					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]);
 					}
@@ -1316,33 +1636,32 @@ 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 (
+				const items = expr.elements.map(
+					element =>
 						element !== null &&
 						element.type !== "SpreadElement" &&
 						this.evaluateExpression(element)
-					);
-				});
+				);
 				if (!items.every(Boolean)) return;
 				return new BasicEvaluatedExpression()
-					.setItems(items)
-					.setRange(expr.range);
+					.setItems(/** @type {BasicEvaluatedExpression[]} */ (items))
+					.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 (
@@ -1353,7 +1672,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;
@@ -1361,7 +1680,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;
@@ -1369,60 +1688,91 @@ 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 && evaluated.asNullish()) {
-						return evaluated.setRange(_expr.range);
+					if (evaluated.asNullish()) {
+						return evaluated.setRange(/** @type {Range} */ (_expr.range));
 					}
 				}
 				return this.evaluateExpression(expr.expression);
 			});
 	}
 
+	/**
+	 * @param {Expression} node node
+	 * @returns {Set<DestructuringAssignmentProperty> | undefined} destructured identifiers
+	 */
+	destructuringAssignmentPropertiesFor(node) {
+		if (!this.destructuringAssignmentProperties) return;
+		return this.destructuringAssignmentProperties.get(node);
+	}
+
+	/**
+	 * @param {Expression} expr expression
+	 * @returns {string | VariableInfoInterface | undefined} identifier
+	 */
 	getRenameIdentifier(expr) {
 		const result = this.evaluateExpression(expr);
-		if (result && result.isIdentifier()) {
+		if (result.isIdentifier()) {
 			return result.identifier;
 		}
 	}
 
 	/**
-	 * @param {ClassExpressionNode | ClassDeclarationNode} classy a class node
+	 * @param {ClassExpression | ClassDeclaration} classy a class node
 	 * @returns {void}
 	 */
 	walkClass(classy) {
-		if (classy.superClass) {
-			if (!this.hooks.classExtendsExpression.call(classy.superClass, classy)) {
-				this.walkExpression(classy.superClass);
-			}
+		if (
+			classy.superClass &&
+			!this.hooks.classExtendsExpression.call(classy.superClass, classy)
+		) {
+			this.walkExpression(classy.superClass);
 		}
 		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;
 						}
 					}
 				}
-			}
+			});
 		}
 	}
 
-	// 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];
@@ -1430,7 +1780,10 @@ 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];
@@ -1438,7 +1791,10 @@ 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];
@@ -1446,6 +1802,10 @@ 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)) {
@@ -1496,6 +1856,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)) {
@@ -1521,10 +1884,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) {
@@ -1597,8 +1965,7 @@ 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;
@@ -1606,10 +1973,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;
@@ -1620,10 +1993,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) {
@@ -1631,6 +2010,9 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @param {IfStatement} statement if statement
+	 */
 	walkIfStatement(statement) {
 		const result = this.hooks.statementIf.call(statement);
 		if (result === undefined) {
@@ -1639,19 +2021,23 @@ class JavascriptParser extends Parser {
 			if (statement.alternate) {
 				this.walkNestedStatement(statement.alternate);
 			}
-		} else {
-			if (result) {
-				this.walkNestedStatement(statement.consequent);
-			} else if (statement.alternate) {
-				this.walkNestedStatement(statement.alternate);
-			}
+		} else if (result) {
+			this.walkNestedStatement(statement.consequent);
+		} else if (statement.alternate) {
+			this.walkNestedStatement(statement.alternate);
 		}
 	}
 
+	/**
+	 * @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) {
@@ -1661,42 +2047,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);
@@ -1709,33 +2122,49 @@ 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") {
-				this.preWalkStatement(statement.init);
-			}
+		if (statement.init && statement.init.type === "VariableDeclaration") {
+			this.preWalkStatement(statement.init);
 		}
 		this.preWalkStatement(statement.body);
 	}
 
+	/**
+	 * @param {ForStatement} statement for statement
+	 */
 	walkForStatement(statement) {
 		this.inBlockScope(() => {
 			if (statement.init) {
@@ -1766,6 +2195,9 @@ class JavascriptParser extends Parser {
 		});
 	}
 
+	/**
+	 * @param {ForInStatement} statement for statement
+	 */
 	preWalkForInStatement(statement) {
 		if (statement.left.type === "VariableDeclaration") {
 			this.preWalkVariableDeclaration(statement.left);
@@ -1773,6 +2205,9 @@ class JavascriptParser extends Parser {
 		this.preWalkStatement(statement.body);
 	}
 
+	/**
+	 * @param {ForInStatement} statement for statement
+	 */
 	walkForInStatement(statement) {
 		this.inBlockScope(() => {
 			if (statement.left.type === "VariableDeclaration") {
@@ -1795,6 +2230,9 @@ class JavascriptParser extends Parser {
 		});
 	}
 
+	/**
+	 * @param {ForOfStatement} statement statement
+	 */
 	preWalkForOfStatement(statement) {
 		if (statement.await && this.scope.topLevelScope === true) {
 			this.hooks.topLevelAwait.call(statement);
@@ -1805,6 +2243,9 @@ class JavascriptParser extends Parser {
 		this.preWalkStatement(statement.body);
 	}
 
+	/**
+	 * @param {ForOfStatement} statement for statement
+	 */
 	walkForOfStatement(statement) {
 		this.inBlockScope(() => {
 			if (statement.left.type === "VariableDeclaration") {
@@ -1827,13 +2268,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;
@@ -1854,8 +2300,55 @@ 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 =
+				/** @type {Set<DestructuringAssignmentProperty>} */
+				(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);
+		}
+	}
+
+	/**
+	 * @param {ImportDeclaration} statement statement
+	 */
 	blockPreWalkImportDeclaration(statement) {
-		const source = statement.source.value;
+		const source = /** @type {ImportSource} */ (statement.source.value);
 		this.hooks.import.call(statement, source);
 		for (const specifier of statement.specifiers) {
 			const name = specifier.local.name;
@@ -1872,7 +2365,12 @@ class JavascriptParser extends Parser {
 						!this.hooks.importSpecifier.call(
 							statement,
 							source,
-							specifier.imported.name,
+							specifier.imported.name ||
+								// eslint-disable-next-line no-warning-comments
+								// @ts-ignore
+								// Old version of acorn used it
+								// TODO drop it in webpack@6
+								specifier.imported.value,
 							name
 						)
 					) {
@@ -1890,6 +2388,10 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @param {Declaration} declaration declaration
+	 * @param {OnIdent} onIdent on ident callback
+	 */
 	enterDeclaration(declaration, onIdent) {
 		switch (declaration.type) {
 			case "VariableDeclaration":
@@ -1911,27 +2413,29 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @param {ExportNamedDeclaration} statement statement
+	 */
 	blockPreWalkExportNamedDeclaration(statement) {
 		let source;
 		if (statement.source) {
-			source = statement.source.value;
+			source = /** @type {ImportSource} */ (statement.source.value);
 			this.hooks.exportImport.call(statement, source);
 		} else {
 			this.hooks.export.call(statement);
 		}
-		if (statement.declaration) {
-			if (
-				!this.hooks.exportDeclaration.call(statement, statement.declaration)
-			) {
-				const prev = this.prevStatement;
-				this.preWalkStatement(statement.declaration);
-				this.prevStatement = prev;
-				this.blockPreWalkStatement(statement.declaration);
-				let index = 0;
-				this.enterDeclaration(statement.declaration, def => {
-					this.hooks.exportSpecifier.call(statement, def, def, index++);
-				});
-			}
+		if (
+			statement.declaration &&
+			!this.hooks.exportDeclaration.call(statement, statement.declaration)
+		) {
+			const prev = this.prevStatement;
+			this.preWalkStatement(statement.declaration);
+			this.prevStatement = prev;
+			this.blockPreWalkStatement(statement.declaration);
+			let index = 0;
+			this.enterDeclaration(statement.declaration, def => {
+				this.hooks.exportSpecifier.call(statement, def, def, index++);
+			});
 		}
 		if (statement.specifiers) {
 			for (
@@ -1942,7 +2446,13 @@ class JavascriptParser extends Parser {
 				const specifier = statement.specifiers[specifierIndex];
 				switch (specifier.type) {
 					case "ExportSpecifier": {
-						const name = specifier.exported.name;
+						const name =
+							specifier.exported.name ||
+							// eslint-disable-next-line no-warning-comments
+							// @ts-ignore
+							// Old version of acorn used it
+							// TODO drop it in webpack@6
+							specifier.exported.value;
 						if (source) {
 							this.hooks.exportImportSpecifier.call(
 								statement,
@@ -1966,42 +2476,59 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @param {ExportNamedDeclaration} statement the statement
+	 */
 	walkExportNamedDeclaration(statement) {
 		if (statement.declaration) {
 			this.walkStatement(statement.declaration);
 		}
 	}
 
+	/**
+	 * @param {TODO} statement statement
+	 */
 	blockPreWalkExportDefaultDeclaration(statement) {
 		const prev = this.prevStatement;
 		this.preWalkStatement(statement.declaration);
 		this.prevStatement = prev;
 		this.blockPreWalkStatement(statement.declaration);
 		if (
-			statement.declaration.id &&
+			/** @type {FunctionDeclaration | ClassDeclaration} */ (
+				statement.declaration
+			).id &&
 			statement.declaration.type !== "FunctionExpression" &&
 			statement.declaration.type !== "ClassExpression"
 		) {
+			const declaration =
+				/** @type {FunctionDeclaration | ClassDeclaration} */
+				(statement.declaration);
 			this.hooks.exportSpecifier.call(
 				statement,
-				statement.declaration.id.name,
+				declaration.id.name,
 				"default",
 				undefined
 			);
 		}
 	}
 
+	/**
+	 * @param {ExportDefaultDeclaration} statement statement
+	 */
 	walkExportDefaultDeclaration(statement) {
 		this.hooks.export.call(statement);
 		if (
-			statement.declaration.id &&
+			/** @type {FunctionDeclaration | ClassDeclaration} */ (
+				statement.declaration
+			).id &&
 			statement.declaration.type !== "FunctionExpression" &&
 			statement.declaration.type !== "ClassExpression"
 		) {
-			if (
-				!this.hooks.exportDeclaration.call(statement, statement.declaration)
-			) {
-				this.walkStatement(statement.declaration);
+			const declaration =
+				/** @type {FunctionDeclaration | ClassDeclaration} */
+				(statement.declaration);
+			if (!this.hooks.exportDeclaration.call(statement, declaration)) {
+				this.walkStatement(declaration);
 			}
 		} else {
 			// Acorn parses `export default function() {}` as `FunctionDeclaration` and
@@ -2011,14 +2538,23 @@ class JavascriptParser extends Parser {
 				statement.declaration.type === "FunctionDeclaration" ||
 				statement.declaration.type === "ClassDeclaration"
 			) {
-				this.walkStatement(statement.declaration);
+				this.walkStatement(
+					/** @type {FunctionDeclaration | ClassDeclaration} */
+					(statement.declaration)
+				);
 			} else {
 				this.walkExpression(statement.declaration);
 			}
-			if (!this.hooks.exportExpression.call(statement, statement.declaration)) {
+
+			if (
+				!this.hooks.exportExpression.call(
+					statement,
+					/** @type {TODO} */ (statement).declaration
+				)
+			) {
 				this.hooks.exportSpecifier.call(
 					statement,
-					statement.declaration,
+					/** @type {TODO} */ (statement.declaration),
 					"default",
 					undefined
 				);
@@ -2026,18 +2562,27 @@ class JavascriptParser extends Parser {
 		}
 	}
 
-	blockPreWalkExportAllDeclaration(statement) {
-		const source = statement.source.value;
+	/**
+	 * @param {ExportAllDeclaration} statement statement
+	 */
+	blockPreWalkExportAllDeclaration(statement) {
+		const source = /** @type {ImportSource} */ (statement.source.value);
 		const name = statement.exported ? statement.exported.name : null;
 		this.hooks.exportImport.call(statement, source);
 		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 =
@@ -2047,10 +2592,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);
@@ -2068,6 +2618,75 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @param {ObjectPattern} objectPattern object pattern
+	 * @returns {Set<DestructuringAssignmentProperty> | undefined} set of names or undefined if not all keys are identifiers
+	 */
+	_preWalkObjectPattern(objectPattern) {
+		/** @type {Set<DestructuringAssignmentProperty>} */
+		const props = new Set();
+		const properties = objectPattern.properties;
+		for (let i = 0; i < properties.length; i++) {
+			const property = properties[i];
+			if (property.type !== "Property") return;
+			if (property.shorthand && property.value.type === "Identifier") {
+				this.scope.inShorthand = property.value.name;
+			}
+			const key = property.key;
+			if (key.type === "Identifier") {
+				props.add({
+					id: key.name,
+					range: key.range,
+					shorthand: this.scope.inShorthand
+				});
+			} else {
+				const id = this.evaluateExpression(/** @type {TODO} */ (key));
+				const str = id.asString();
+				if (str) {
+					props.add({
+						id: str,
+						range: key.range,
+						shorthand: this.scope.inShorthand
+					});
+				} else {
+					// could not evaluate key
+					return;
+				}
+			}
+			this.scope.inShorthand = false;
+		}
+
+		return props;
+	}
+
+	/**
+	 * @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) {
@@ -2076,10 +2695,16 @@ class JavascriptParser extends Parser {
 						declarator.init && this.getRenameIdentifier(declarator.init);
 					if (renameIdentifier && declarator.id.type === "Identifier") {
 						const hook = this.hooks.canRename.get(renameIdentifier);
-						if (hook !== undefined && hook.call(declarator.init)) {
+						if (
+							hook !== undefined &&
+							hook.call(/** @type {Expression} */ (declarator.init))
+						) {
 							// renaming with "var a = b;"
 							const hook = this.hooks.rename.get(renameIdentifier);
-							if (hook === undefined || !hook.call(declarator.init)) {
+							if (
+								hook === undefined ||
+								!hook.call(/** @type {Expression} */ (declarator.init))
+							) {
 								this.setVariable(declarator.id.name, renameIdentifier);
 							}
 							break;
@@ -2095,16 +2720,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];
@@ -2112,6 +2746,9 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @param {SwitchCase[]} switchCases switch statement
+	 */
 	walkSwitchCases(switchCases) {
 		this.inBlockScope(() => {
 			const len = switchCases.length;
@@ -2147,10 +2784,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
@@ -2167,6 +2810,9 @@ class JavascriptParser extends Parser {
 		});
 	}
 
+	/**
+	 * @param {Pattern} pattern pattern
+	 */
 	walkPattern(pattern) {
 		switch (pattern.type) {
 			case "ArrayPattern":
@@ -2187,21 +2833,33 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @param {AssignmentPattern} pattern assignment pattern
+	 */
 	walkAssignmentPattern(pattern) {
 		this.walkExpression(pattern.right);
 		this.walkPattern(pattern.left);
 	}
 
+	/**
+	 * @param {ObjectPattern} pattern pattern
+	 */
 	walkObjectPattern(pattern) {
 		for (let i = 0, len = pattern.properties.length; i < len; i++) {
 			const prop = pattern.properties[i];
 			if (prop) {
+				if (prop.type === "RestElement") {
+					continue;
+				}
 				if (prop.computed) this.walkExpression(prop.key);
 				if (prop.value) this.walkPattern(prop.value);
 			}
 		}
 	}
 
+	/**
+	 * @param {ArrayPattern} pattern array pattern
+	 */
 	walkArrayPattern(pattern) {
 		for (let i = 0, len = pattern.elements.length; i < len; i++) {
 			const element = pattern.elements[i];
@@ -2209,10 +2867,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) {
@@ -2221,6 +2885,9 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @param {TODO} expression expression
+	 */
 	walkExpression(expression) {
 		switch (expression.type) {
 			case "ArrayExpression":
@@ -2301,24 +2968,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;
@@ -2330,6 +3009,9 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @param {Property | SpreadElement} prop property or spread element
+	 */
 	walkProperty(prop) {
 		if (prop.type === "SpreadElement") {
 			this.walkExpression(prop.argument);
@@ -2347,14 +3029,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, () => {
@@ -2374,6 +3059,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;
@@ -2395,7 +3083,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
-	 * @param {SequenceExpressionNode} expression the sequence
+	 * @param {SequenceExpression} expression the sequence
 	 */
 	walkSequenceExpression(expression) {
 		if (!expression.expressions) return;
@@ -2407,22 +3095,30 @@ class JavascriptParser extends Parser {
 			(currentStatement.type === "ExpressionStatement" &&
 				currentStatement.expression === expression)
 		) {
-			const old = this.statementPath.pop();
+			const old = /** @type {StatementPathItem} */ (this.statementPath.pop());
+			const prev = this.prevStatement;
 			for (const expr of expression.expressions) {
 				this.statementPath.push(expr);
 				this.walkExpression(expr);
-				this.statementPath.pop();
+				this.prevStatement = this.statementPath.pop();
 			}
+			this.prevStatement = prev;
 			this.statementPath.push(old);
 		} else {
 			this.walkExpressions(expression.expressions);
 		}
 	}
 
+	/**
+	 * @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(
@@ -2443,52 +3139,65 @@ 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) {
-		this.walkLeftRightExpression(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) {
 			this.walkLeftRightExpression(expression);
-		} else {
-			if (result) {
-				this.walkExpression(expression.right);
-			}
+		} else if (result) {
+			this.walkExpression(expression.right);
 		}
 	}
 
+	/**
+	 * @param {AssignmentExpression} expression assignment expression
+	 */
 	walkAssignmentExpression(expression) {
 		if (expression.left.type === "Identifier") {
 			const renameIdentifier = this.getRenameIdentifier(expression.right);
-			if (renameIdentifier) {
+			if (
+				renameIdentifier &&
+				this.callHooksForInfo(
+					this.hooks.canRename,
+					renameIdentifier,
+					expression.right
+				)
+			) {
+				// renaming "a = b;"
 				if (
-					this.callHooksForInfo(
-						this.hooks.canRename,
+					!this.callHooksForInfo(
+						this.hooks.rename,
 						renameIdentifier,
 						expression.right
 					)
 				) {
-					// renaming "a = b;"
-					if (
-						!this.callHooksForInfo(
-							this.hooks.rename,
-							renameIdentifier,
-							expression.right
-						)
-					) {
-						this.setVariable(
-							expression.left.name,
-							this.getVariableInfo(renameIdentifier)
-						);
-					}
-					return;
+					this.setVariable(
+						expression.left.name,
+						typeof renameIdentifier === "string"
+							? this.getVariableInfo(renameIdentifier)
+							: renameIdentifier
+					);
 				}
+				return;
 			}
 			this.walkExpression(expression.right);
 			this.enterPattern(expression.left, (name, decl) => {
@@ -2511,17 +3220,16 @@ class JavascriptParser extends Parser {
 				expression.left,
 				ALLOWED_MEMBER_TYPES_EXPRESSION
 			);
-			if (exprName) {
-				if (
-					this.callHooksForInfo(
-						this.hooks.assignMemberChain,
-						exprName.rootInfo,
-						expression,
-						exprName.getMembers()
-					)
-				) {
-					return;
-				}
+			if (
+				exprName &&
+				this.callHooksForInfo(
+					this.hooks.assignMemberChain,
+					exprName.rootInfo,
+					expression,
+					exprName.getMembers()
+				)
+			) {
+				return;
 			}
 			this.walkExpression(expression.right);
 			this.walkExpression(expression.left);
@@ -2531,6 +3239,9 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @param {ConditionalExpression} expression conditional expression
+	 */
 	walkConditionalExpression(expression) {
 		const result = this.hooks.expressionConditionalOperator.call(expression);
 		if (result === undefined) {
@@ -2539,15 +3250,16 @@ class JavascriptParser extends Parser {
 			if (expression.alternate) {
 				this.walkExpression(expression.alternate);
 			}
-		} else {
-			if (result) {
-				this.walkExpression(expression.consequent);
-			} else if (expression.alternate) {
-				this.walkExpression(expression.alternate);
-			}
+		} else if (result) {
+			this.walkExpression(expression.consequent);
+		} else if (expression.alternate) {
+			this.walkExpression(expression.alternate);
 		}
 	}
 
+	/**
+	 * @param {NewExpression} expression new expression
+	 */
 	walkNewExpression(expression) {
 		const result = this.callHooksForExpression(
 			this.hooks.new,
@@ -2561,33 +3273,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);
@@ -2601,27 +3327,33 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @private
+	 * @param {FunctionExpression | ArrowFunctionExpression} functionExpression function expression
+	 * @param {(Expression | SpreadElement)[]} options options
+	 * @param {Expression | SpreadElement | null} currentThis current this
+	 */
 	_walkIIFE(functionExpression, options, currentThis) {
+		/**
+		 * @param {Expression | SpreadElement} argOrThis arg or this
+		 * @returns {string | VariableInfoInterface | undefined} var info
+		 */
 		const getVarInfo = argOrThis => {
-			const renameIdentifier = this.getRenameIdentifier(argOrThis);
-			if (renameIdentifier) {
-				if (
-					this.callHooksForInfo(
-						this.hooks.canRename,
-						renameIdentifier,
-						argOrThis
-					)
-				) {
-					if (
-						!this.callHooksForInfo(
-							this.hooks.rename,
-							renameIdentifier,
-							argOrThis
-						)
-					) {
-						return this.getVariableInfo(renameIdentifier);
-					}
-				}
+			const renameIdentifier = this.getRenameIdentifier(
+				/** @type {Expression} */ (argOrThis)
+			);
+			if (
+				renameIdentifier &&
+				this.callHooksForInfo(
+					this.hooks.canRename,
+					renameIdentifier,
+					argOrThis
+				) &&
+				!this.callHooksForInfo(this.hooks.rename, renameIdentifier, argOrThis)
+			) {
+				return typeof renameIdentifier === "string"
+					? /** @type {string} */ (this.getVariableInfo(renameIdentifier))
+					: renameIdentifier;
 			}
 			this.walkExpression(argOrThis);
 		};
@@ -2631,12 +3363,15 @@ class JavascriptParser extends Parser {
 		const varInfoForArgs = options.map(getVarInfo);
 		const wasTopLevel = this.scope.topLevelScope;
 		this.scope.topLevelScope = wasTopLevel && arrow ? "arrow" : false;
-		const scopeParams = params.filter(
-			(identifier, idx) => !varInfoForArgs[idx]
-		);
+		const scopeParams =
+			/** @type {(Identifier | string)[]} */
+			(params.filter((identifier, idx) => !varInfoForArgs[idx]));
 
 		// Add function name in scope for recursive calls
-		if (functionExpression.id) {
+		if (
+			functionExpression.type === "FunctionExpression" &&
+			functionExpression.id
+		) {
 			scopeParams.push(functionExpression.id.name);
 		}
 
@@ -2648,7 +3383,7 @@ class JavascriptParser extends Parser {
 				const varInfo = varInfoForArgs[i];
 				if (!varInfo) continue;
 				if (!params[i] || params[i].type !== "Identifier") continue;
-				this.setVariable(params[i].name, varInfo);
+				this.setVariable(/** @type {Identifier} */ (params[i]).name, varInfo);
 			}
 			if (functionExpression.body.type === "BlockStatement") {
 				this.detectMode(functionExpression.body.body);
@@ -2663,29 +3398,40 @@ class JavascriptParser extends Parser {
 		this.scope.topLevelScope = wasTopLevel;
 	}
 
+	/**
+	 * @param {ImportExpression} expression import expression
+	 */
 	walkImportExpression(expression) {
-		let result = this.hooks.importCall.call(expression);
+		const result = this.hooks.importCall.call(expression);
 		if (result === true) return;
 
 		this.walkExpression(expression.source);
 	}
 
+	/**
+	 * @param {CallExpression} expression expression
+	 */
 	walkCallExpression(expression) {
-		const isSimpleFunction = fn => {
-			return fn.params.every(p => p.type === "Identifier");
-		};
+		const isSimpleFunction = fn =>
+			fn.params.every(p => p.type === "Identifier");
 		if (
 			expression.callee.type === "MemberExpression" &&
 			expression.callee.object.type.endsWith("FunctionExpression") &&
 			!expression.callee.computed &&
+			// eslint-disable-next-line no-warning-comments
+			// @ts-ignore
+			// TODO check me and handle more cases
 			(expression.callee.property.name === "call" ||
+				// eslint-disable-next-line no-warning-comments
+				// @ts-ignore
 				expression.callee.property.name === "bind") &&
 			expression.arguments.length > 0 &&
 			isSimpleFunction(expression.callee.object)
 		) {
 			// (function(…) { }.call/bind(?, …))
 			this._walkIIFE(
-				expression.callee.object,
+				/** @type {FunctionExpression | ArrowFunctionExpression} */
+				(expression.callee.object),
 				expression.arguments.slice(1),
 				expression.arguments[0]
 			);
@@ -2694,7 +3440,12 @@ class JavascriptParser extends Parser {
 			isSimpleFunction(expression.callee)
 		) {
 			// (function(…) { }(…))
-			this._walkIIFE(expression.callee, expression.arguments, null);
+			this._walkIIFE(
+				/** @type {FunctionExpression | ArrowFunctionExpression} */
+				(expression.callee),
+				expression.arguments,
+				null
+			);
 		} else {
 			if (expression.callee.type === "MemberExpression") {
 				const exprInfo = this.getMemberExpressionInfo(
@@ -2708,18 +3459,25 @@ class JavascriptParser extends Parser {
 						expression,
 						exprInfo.getCalleeMembers(),
 						exprInfo.call,
-						exprInfo.getMembers()
+						exprInfo.getMembers(),
+						exprInfo.getMemberRanges()
 					);
 					if (result === true) return;
 				}
 			}
-			const callee = this.evaluateExpression(expression.callee);
+			const callee = this.evaluateExpression(
+				/** @type {TODO} */ (expression.callee)
+			);
 			if (callee.isIdentifier()) {
 				const result1 = this.callHooksForInfo(
 					this.hooks.callMemberChain,
 					callee.rootInfo,
 					expression,
-					callee.getMembers()
+					callee.getMembers(),
+					callee.getMembersOptionals
+						? callee.getMembersOptionals()
+						: callee.getMembers().map(() => false),
+					callee.getMemberRanges ? callee.getMemberRanges() : []
 				);
 				if (result1 === true) return;
 				const result2 = this.callHooksForInfo(
@@ -2744,6 +3502,9 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @param {MemberExpression} expression member expression
+	 */
 	walkMemberExpression(expression) {
 		const exprInfo = this.getMemberExpressionInfo(
 			expression,
@@ -2759,11 +3520,15 @@ 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
+						members,
+						membersOptionals,
+						memberRanges
 					);
 					if (result2 === true) return;
 					this.walkMemberExpressionWithExpressionName(
@@ -2788,7 +3553,8 @@ class JavascriptParser extends Parser {
 						expression,
 						exprInfo.getCalleeMembers(),
 						exprInfo.call,
-						exprInfo.getMembers()
+						exprInfo.getMembers(),
+						exprInfo.getMemberRanges()
 					);
 					if (result === true) return;
 					// Fast skip over the member chain as we already called memberChainOfCallMemberChain
@@ -2802,6 +3568,13 @@ class JavascriptParser extends Parser {
 		if (expression.computed === true) this.walkExpression(expression.property);
 	}
 
+	/**
+	 * @param {TODO} expression member expression
+	 * @param {string} name name
+	 * @param {string | VariableInfo} rootInfo root info
+	 * @param {string[]} members members
+	 * @param {TODO} onUnhandled on unhandled callback
+	 */
 	walkMemberExpressionWithExpressionName(
 		expression,
 		name,
@@ -2835,21 +3608,35 @@ 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);
 	}
 
+	/**
+	 * @template T
+	 * @template R
+	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks the should be called
+	 * @param {TODO} expr expression
+	 * @param {AsArray<T>} args args for the hook
+	 * @returns {R | undefined} result of hook
+	 */
 	callHooksForExpression(hookMap, expr, ...args) {
 		return this.callHooksForExpressionWithFallback(
 			hookMap,
@@ -2864,11 +3651,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,
@@ -2900,7 +3687,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(
@@ -2918,7 +3705,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(
@@ -2935,10 +3722,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;
@@ -2985,10 +3772,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(
@@ -3012,6 +3799,7 @@ class JavascriptParser extends Parser {
 			topLevelScope: oldScope.topLevelScope,
 			inTry: false,
 			inShorthand: false,
+			inTaggedTemplateTag: false,
 			isStrict: oldScope.isStrict,
 			isAsmJs: oldScope.isAsmJs,
 			definitions: oldScope.definitions.createChild()
@@ -3028,12 +3816,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()
@@ -3052,12 +3878,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()
@@ -3068,19 +3899,36 @@ 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;
 		}
 	}
 
+	/**
+	 * @param {(string | Pattern | Property)[]} patterns patterns
+	 * @param {OnIdent} onIdent on ident callback
+	 */
 	enterPatterns(patterns, onIdent) {
 		for (const pattern of patterns) {
 			if (typeof pattern !== "string") {
@@ -3091,6 +3939,10 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @param {Pattern | Property} pattern pattern
+	 * @param {OnIdent} onIdent on ident callback
+	 */
 	enterPattern(pattern, onIdent) {
 		if (!pattern) return;
 		switch (pattern.type) {
@@ -3115,18 +3967,26 @@ class JavascriptParser extends Parser {
 					this.enterIdentifier(pattern.value, onIdent);
 					this.scope.inShorthand = false;
 				} else {
-					this.enterPattern(pattern.value, onIdent);
+					this.enterPattern(/** @type {Identifier} */ (pattern.value), onIdent);
 				}
 				break;
 		}
 	}
 
+	/**
+	 * @param {Identifier} pattern identifier pattern
+	 * @param {OnIdent} onIdent callback
+	 */
 	enterIdentifier(pattern, onIdent) {
 		if (!this.callHooksForName(this.hooks.pattern, pattern.name, pattern)) {
 			onIdent(pattern.name, pattern);
 		}
 	}
 
+	/**
+	 * @param {ObjectPattern} pattern object pattern
+	 * @param {OnIdent} onIdent callback
+	 */
 	enterObjectPattern(pattern, onIdent) {
 		for (
 			let propIndex = 0, len = pattern.properties.length;
@@ -3138,6 +3998,10 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @param {ArrayPattern} pattern object pattern
+	 * @param {OnIdent} onIdent callback
+	 */
 	enterArrayPattern(pattern, onIdent) {
 		for (
 			let elementIndex = 0, len = pattern.elements.length;
@@ -3145,43 +4009,56 @@ class JavascriptParser extends Parser {
 			elementIndex++
 		) {
 			const element = pattern.elements[elementIndex];
-			this.enterPattern(element, onIdent);
+
+			if (element) {
+				this.enterPattern(element, onIdent);
+			}
 		}
 	}
 
+	/**
+	 * @param {RestElement} pattern object pattern
+	 * @param {OnIdent} onIdent callback
+	 */
 	enterRestElement(pattern, onIdent) {
 		this.enterPattern(pattern.argument, onIdent);
 	}
 
+	/**
+	 * @param {AssignmentPattern} pattern object pattern
+	 * @param {OnIdent} onIdent callback
+	 */
 	enterAssignmentPattern(pattern, onIdent) {
 		this.enterPattern(pattern.left, onIdent);
 	}
 
 	/**
-	 * @param {ExpressionNode} expression expression node
-	 * @returns {BasicEvaluatedExpression | undefined} evaluation result
+	 * @param {Expression | SpreadElement} expression expression node
+	 * @returns {BasicEvaluatedExpression} evaluation result
 	 */
 	evaluateExpression(expression) {
 		try {
 			const hook = this.hooks.evaluate.get(expression.type);
 			if (hook !== undefined) {
 				const result = hook.call(expression);
-				if (result !== undefined) {
-					if (result) {
-						result.setExpression(expression);
-					}
+				if (result !== undefined && result !== null) {
+					result.setExpression(expression);
 					return result;
 				}
 			}
-		} catch (e) {
-			console.warn(e);
+		} catch (err) {
+			console.warn(err);
 			// 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":
@@ -3193,13 +4070,17 @@ class JavascriptParser extends Parser {
 				}
 				break;
 			case "Literal":
-				return expression.value + "";
+				return String(expression.value);
 		}
 		throw new Error(
-			expression.type + " is not supported as parameter for require"
+			`${expression.type} is not supported as parameter for require`
 		);
 	}
 
+	/**
+	 * @param {Expression} expression expression
+	 * @returns {TODO} result
+	 */
 	parseCalculatedString(expression) {
 		switch (expression.type) {
 			case "BinaryExpression":
@@ -3223,14 +4104,13 @@ class JavascriptParser extends Parser {
 							code: true,
 							conditional: false
 						};
-					} else {
-						return {
-							range: [left.range[0], right.range[1]],
-							value: left.value + right.value,
-							code: false,
-							conditional: false
-						};
 					}
+					return {
+						range: [left.range[0], right.range[1]],
+						value: left.value + right.value,
+						code: false,
+						conditional: false
+					};
 				}
 				break;
 			case "ConditionalExpression": {
@@ -3261,7 +4141,7 @@ class JavascriptParser extends Parser {
 			case "Literal":
 				return {
 					range: expression.range,
-					value: expression.value + "",
+					value: String(expression.value),
 					code: false,
 					conditional: false
 				};
@@ -3290,7 +4170,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 = [];
@@ -3311,6 +4191,7 @@ class JavascriptParser extends Parser {
 			topLevelScope: true,
 			inTry: false,
 			inShorthand: false,
+			inTaggedTemplateTag: false,
 			isStrict: false,
 			isAsmJs: false,
 			definitions: new StackedMap()
@@ -3322,12 +4203,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;
@@ -3340,8 +4223,12 @@ class JavascriptParser extends Parser {
 		return state;
 	}
 
+	/**
+	 * @param {string} source source code
+	 * @returns {BasicEvaluatedExpression} evaluation result
+	 */
 	evaluate(source) {
-		const ast = JavascriptParser._parse("(" + source + ")", {
+		const ast = JavascriptParser._parse(`(${source})`, {
 			sourceType: this.sourceType,
 			locations: false
 		});
@@ -3352,7 +4239,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
 	 */
@@ -3363,70 +4250,113 @@ 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;
-				if (expr.superClass && !this.isPure(expr.superClass, expr.range[0])) {
+				if (
+					expr.superClass &&
+					!this.isPure(expr.superClass, /** @type {Range} */ (expr.range)[0])
+				) {
 					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;
+					}
+
+					if (
+						expr.superClass &&
+						item.type === "MethodDefinition" &&
+						item.kind === "constructor"
+					) {
+						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;
 				});
 			}
@@ -3435,13 +4365,28 @@ class JavascriptParser extends Parser {
 		return !evaluated.couldHaveSideEffects();
 	}
 
+	/**
+	 * @param {Range} range range
+	 * @returns {Comment[]} comments in the range
+	 */
 	getComments(range) {
 		const [rangeStart, rangeEnd] = range;
-		const compare = (comment, needle) => comment.range[0] - needle;
-		let idx = binarySearchBounds.ge(this.comments, rangeStart, compare);
-		let commentsInRange = [];
-		while (this.comments[idx] && this.comments[idx].range[1] <= rangeEnd) {
-			commentsInRange.push(this.comments[idx]);
+		/**
+		 * @param {Comment} comment comment
+		 * @param {number} needle needle
+		 * @returns {number} compared
+		 */
+		const compare = (comment, needle) =>
+			/** @type {Range} */ (comment.range)[0] - needle;
+		const comments = /** @type {Comment[]} */ (this.comments);
+		let idx = binarySearchBounds.ge(comments, rangeStart, compare);
+		/** @type {Comment[]} */
+		const commentsInRange = [];
+		while (
+			comments[idx] &&
+			/** @type {Range} */ (comments[idx].range)[1] <= rangeEnd
+		) {
+			commentsInRange.push(comments[idx]);
 			idx++;
 		}
 
@@ -3457,25 +4402,40 @@ class JavascriptParser extends Parser {
 		if (currentStatement === undefined) throw new Error("Not in statement");
 		return (
 			// Either asking directly for the end position of the current statement
-			(currentStatement.range[1] === pos && this.semicolons.has(pos)) ||
+			(currentStatement.range[1] === pos &&
+				/** @type {Set<number>} */ (this.semicolons).has(pos)) ||
 			// Or asking for the start position of the current statement,
 			// here we have to check multiple things
 			(currentStatement.range[0] === pos &&
 				// is there a previous statement which might be relevant?
 				this.prevStatement !== undefined &&
 				// is the end position of the previous statement an ASI position?
-				this.semicolons.has(this.prevStatement.range[1]))
+				/** @type {Set<number>} */ (this.semicolons).has(
+					this.prevStatement.range[1]
+				))
 		);
 	}
 
+	/**
+	 * @param {number} pos source code position
+	 * @returns {void}
+	 */
+	setAsiPosition(pos) {
+		/** @type {Set<number>} */ (this.semicolons).add(pos);
+	}
+
 	/**
 	 * @param {number} pos source code position
 	 * @returns {void}
 	 */
 	unsetAsiPosition(pos) {
-		this.semicolons.delete(pos);
+		/** @type {Set<number>} */ (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 (
@@ -3485,6 +4445,11 @@ class JavascriptParser extends Parser {
 		);
 	}
 
+	/**
+	 * @param {string} name name
+	 * @param {TODO} tag tag info
+	 * @returns {TODO} tag data
+	 */
 	getTagData(name, tag) {
 		const info = this.scope.definitions.get(name);
 		if (info instanceof VariableInfo) {
@@ -3496,6 +4461,11 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @param {string} name name
+	 * @param {TODO} tag tag info
+	 * @param {TODO=} data data
+	 */
 	tagVariable(name, tag, data) {
 		const oldInfo = this.scope.definitions.get(name);
 		/** @type {VariableInfo} */
@@ -3522,6 +4492,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
@@ -3530,10 +4503,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;
@@ -3545,20 +4525,19 @@ class JavascriptParser extends Parser {
 
 	/**
 	 * @param {string} name variable name
-	 * @returns {ExportedVariableInfo} info for this variable
+	 * @returns {string | ExportedVariableInfo} info for this variable
 	 */
 	getVariableInfo(name) {
 		const value = this.scope.definitions.get(name);
 		if (value === undefined) {
 			return name;
-		} else {
-			return value;
 		}
+		return value;
 	}
 
 	/**
 	 * @param {string} name variable name
-	 * @param {ExportedVariableInfo} variableInfo new info for this variable
+	 * @param {string | ExportedVariableInfo} variableInfo new info for this variable
 	 * @returns {void}
 	 */
 	setVariable(name, variableInfo) {
@@ -3576,23 +4555,50 @@ 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) {
 			return EMPTY_COMMENT_OPTIONS;
 		}
-		let options = {};
-		let errors = [];
+		const options = {};
+		/** @type {unknown[]} */
+		const errors = [];
 		for (const comment of comments) {
 			const { value } = comment;
 			if (value && webpackCommentRegExp.test(value)) {
 				// try compile only if webpack options comment is present
 				try {
-					const val = vm.runInNewContext(`(function(){return {${value}};})()`);
-					Object.assign(options, val);
-				} catch (e) {
-					e.comment = comment;
-					errors.push(e);
+					for (let [key, val] of Object.entries(
+						vm.runInContext(
+							`(function(){return {${value}};})()`,
+							this.magicCommentContext
+						)
+					)) {
+						if (typeof val === "object" && val !== null) {
+							val =
+								val.constructor.name === "RegExp"
+									? new RegExp(val)
+									: JSON.parse(JSON.stringify(val));
+						}
+						options[key] = val;
+					}
+				} catch (err) {
+					const newErr = new Error(String(err.message));
+					newErr.stack = String(err.stack);
+					Object.assign(newErr, { comment });
+					errors.push(newErr);
 				}
 			}
 		}
@@ -3600,61 +4606,69 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
-	 * @param {MemberExpressionNode} expression a member expression
-	 * @returns {{ members: string[], object: ExpressionNode | SuperNode }} 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(/** @type {Range} */ (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(/** @type {Range} */ (expr.object.range)); // the range of the expression fragment before the identifier
 			}
+			membersOptionals.push(expr.optional);
 			expr = expr.object;
 		}
+
 		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);
 		let name;
 		if (info instanceof VariableInfo) {
 			name = info.freeName;
-			if (typeof name !== "string") return undefined;
+			if (typeof name !== "string") return;
 		} else if (typeof info !== "string") {
-			return undefined;
+			return;
 		} else {
 			name = info;
 		}
 		return { info, name };
 	}
 
-	/** @typedef {{ type: "call", call: CallExpressionNode, calleeName: string, rootInfo: string | VariableInfo, getCalleeMembers: () => string[], name: string, getMembers: () => string[]}} CallExpressionInfo */
-	/** @typedef {{ type: "expression", rootInfo: string | VariableInfo, name: string, getMembers: () => string[]}} 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 } = this.extractMemberExpressionChain(expression);
+		const { object, members, membersOptionals, memberRanges } =
+			this.extractMemberExpressionChain(expression);
 		switch (object.type) {
 			case "CallExpression": {
-				if ((allowedTypes & ALLOWED_MEMBER_TYPES_CALL_EXPRESSION) === 0)
-					return undefined;
+				if ((allowedTypes & ALLOWED_MEMBER_TYPES_CALL_EXPRESSION) === 0) return;
 				let callee = object.callee;
 				let rootMembers = EMPTY_ARRAY;
 				if (callee.type === "MemberExpression") {
@@ -3662,9 +4676,9 @@ class JavascriptParser extends Parser {
 						this.extractMemberExpressionChain(callee));
 				}
 				const rootName = getRootName(callee);
-				if (!rootName) return undefined;
+				if (!rootName) return;
 				const result = this.getFreeInfoFromVariable(rootName);
-				if (!result) return undefined;
+				if (!result) return;
 				const { info: rootInfo, name: resolvedRoot } = result;
 				const calleeName = objectAndMembersToName(resolvedRoot, rootMembers);
 				return {
@@ -3674,33 +4688,36 @@ class JavascriptParser extends Parser {
 					rootInfo,
 					getCalleeMembers: memoize(() => rootMembers.reverse()),
 					name: objectAndMembersToName(`${calleeName}()`, members),
-					getMembers: memoize(() => members.reverse())
+					getMembers: memoize(() => members.reverse()),
+					getMembersOptionals: memoize(() => membersOptionals.reverse()),
+					getMemberRanges: memoize(() => memberRanges.reverse())
 				};
 			}
 			case "Identifier":
 			case "MetaProperty":
 			case "ThisExpression": {
-				if ((allowedTypes & ALLOWED_MEMBER_TYPES_EXPRESSION) === 0)
-					return undefined;
+				if ((allowedTypes & ALLOWED_MEMBER_TYPES_EXPRESSION) === 0) return;
 				const rootName = getRootName(object);
-				if (!rootName) return undefined;
+				if (!rootName) return;
 
 				const result = this.getFreeInfoFromVariable(rootName);
-				if (!result) return undefined;
+				if (!result) return;
 				const { info: rootInfo, name: resolvedRoot } = result;
 				return {
 					type: "expression",
 					name: objectAndMembersToName(resolvedRoot, members),
 					rootInfo,
-					getMembers: memoize(() => members.reverse())
+					getMembers: memoize(() => members.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(
@@ -3712,7 +4729,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";
@@ -3724,14 +4741,14 @@ class JavascriptParser extends Parser {
 			sourceType: type === "auto" ? "module" : type
 		};
 
-		/** @type {AnyNode} */
+		/** @type {AnyNode | undefined} */
 		let ast;
 		let error;
 		let threw = false;
 		try {
 			ast = /** @type {AnyNode} */ (parser.parse(code, parserOptions));
-		} catch (e) {
-			error = e;
+		} catch (err) {
+			error = err;
 			threw = true;
 		}
 
@@ -3746,7 +4763,7 @@ class JavascriptParser extends Parser {
 			try {
 				ast = /** @type {AnyNode} */ (parser.parse(code, parserOptions));
 				threw = false;
-			} catch (e) {
+			} catch (_err) {
 				// we use the error from first parse try
 				// so nothing to do here
 			}
@@ -3756,7 +4773,7 @@ class JavascriptParser extends Parser {
 			throw error;
 		}
 
-		return /** @type {ProgramNode} */ (ast);
+		return /** @type {Program} */ (ast);
 	}
 }