webpack 5.97.1 → 5.104.1

package/lib/javascript/JavascriptParser.js

@@ -5,37 +5,41 @@
 
 "use strict";
 
-const { Parser: AcornParser, tokTypes } = require("acorn");
-const { SyncBailHook, HookMap } = require("tapable");
 const vm = require("vm");
+const { Parser: AcornParser, tokTypes } = require("acorn");
+const { HookMap, SyncBailHook } = require("tapable");
+const NormalModule = require("../NormalModule");
 const Parser = require("../Parser");
 const StackedMap = require("../util/StackedMap");
 const binarySearchBounds = require("../util/binarySearchBounds");
 const {
-	webpackCommentRegExp,
-	createMagicCommentContext
+	createMagicCommentContext,
+	webpackCommentRegExp
 } = require("../util/magicComment");
 const memoize = require("../util/memoize");
 const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
 
 /** @typedef {import("acorn").Options} AcornOptions */
+/** @typedef {import("acorn").ecmaVersion} EcmaVersion */
 /** @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").ClassDeclaration} ClassDeclaration */
 /** @typedef {import("estree").ForStatement} ForStatement */
 /** @typedef {import("estree").SwitchStatement} SwitchStatement */
 /** @typedef {import("estree").ClassExpression} ClassExpression */
-/** @typedef {import("estree").Comment} Comment */
+/** @typedef {import("estree").SourceLocation} SourceLocation */
+/** @typedef {import("estree").Comment & { start: number, end: number, loc: SourceLocation }} 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").ImportAttribute} ImportAttribute */
+/** @typedef {import("estree").ImportDeclaration} ImportDeclaration */
 /** @typedef {import("estree").Identifier} Identifier */
 /** @typedef {import("estree").VariableDeclaration} VariableDeclaration */
 /** @typedef {import("estree").IfStatement} IfStatement */
@@ -48,7 +52,6 @@ const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
 /** @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 */
@@ -74,6 +77,8 @@ const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
 /** @typedef {import("estree").WhileStatement} WhileStatement */
 /** @typedef {import("estree").ArrowFunctionExpression} ArrowFunctionExpression */
 /** @typedef {import("estree").ExpressionStatement} ExpressionStatement */
+/** @typedef {import("estree").ExportAllDeclaration} ExportAllDeclaration */
+/** @typedef {import("estree").ExportNamedDeclaration} ExportNamedDeclaration */
 /** @typedef {import("estree").FunctionDeclaration} FunctionDeclaration */
 /** @typedef {import("estree").DoWhileStatement} DoWhileStatement */
 /** @typedef {import("estree").TryStatement} TryStatement */
@@ -85,27 +90,42 @@ const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
 /** @typedef {import("estree").Super} Super */
 /** @typedef {import("estree").TaggedTemplateExpression} TaggedTemplateExpression */
 /** @typedef {import("estree").TemplateLiteral} TemplateLiteral */
-/** @typedef {import("estree").AssignmentProperty} AssignmentProperty */
+/** @typedef {import("estree").ModuleDeclaration} ModuleDeclaration */
+/** @typedef {import("estree").MaybeNamedFunctionDeclaration} MaybeNamedFunctionDeclaration */
+/** @typedef {import("estree").MaybeNamedClassDeclaration} MaybeNamedClassDeclaration */
 /**
  * @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 | undefined, tagInfo: TagInfo | undefined}} VariableInfoInterface */
-/** @typedef {{ name: string | VariableInfo, rootInfo: string | VariableInfo, getMembers: () => string[], getMembersOptionals: () => boolean[], getMemberRanges: () => Range[] }} GetInfoResult */
-/** @typedef {Statement | ModuleDeclaration | Expression} StatementPathItem */
-/** @typedef {function(string): void} OnIdentString */
-/** @typedef {function(string, Identifier): void} OnIdent */
+
+/** @typedef {import("../dependencies/LocalModule")} LocalModule */
+/** @typedef {import("../dependencies/HarmonyExportImportedSpecifierDependency").HarmonyStarExportsList} HarmonyStarExportsList */
+
+/**
+ * @typedef {object} KnownJavascriptParserState
+ * @property {Set<string>=} harmonyNamedExports
+ * @property {HarmonyStarExportsList=} harmonyStarExports
+ * @property {number=} lastHarmonyImportOrder
+ * @property {LocalModule[]=} localModules
+ */
+
+/** @typedef {ParserState & KnownJavascriptParserState} JavascriptParserState */
+
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Module")} Module */
+
+/** @typedef {{ name: string | VariableInfo, rootInfo: string | VariableInfo, getMembers: () => Members, getMembersOptionals: () => MembersOptionals, getMemberRanges: () => MemberRanges }} GetInfoResult */
+/** @typedef {Statement | ModuleDeclaration | Expression | MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration} StatementPathItem */
+/** @typedef {(ident: string) => void} OnIdentString */
+/** @typedef {(ident: string, identifier: Identifier) => void} OnIdent */
 /** @typedef {StatementPathItem[]} StatementPath */
 
+/** @typedef {Set<DestructuringAssignmentProperty>} DestructuringAssignmentProperties */
+
 // TODO remove cast when @types/estree has been updated to import assertions
-/** @typedef {import("estree").BaseNode & { type: "ImportAttribute", key: Identifier | Literal, value: Literal }} ImportAttribute */
-/** @typedef {import("estree").ImportDeclaration & { attributes?: Array<ImportAttribute> }} ImportDeclaration */
-/** @typedef {import("estree").ExportNamedDeclaration & { attributes?: Array<ImportAttribute> }} ExportNamedDeclaration */
-/** @typedef {import("estree").ExportAllDeclaration & { attributes?: Array<ImportAttribute> }} ExportAllDeclaration */
-/** @typedef {import("estree").ImportExpression & { options?: Expression | null }} ImportExpression */
-/** @typedef {ImportDeclaration | ExportNamedDeclaration | ExportDefaultDeclaration | ExportAllDeclaration} ModuleDeclaration */
+/** @typedef {import("estree").ImportExpression & { phase?: "defer" }} ImportExpression */
 
 /** @type {string[]} */
 const EMPTY_ARRAY = [];
@@ -115,69 +135,71 @@ const ALLOWED_MEMBER_TYPES_ALL = 0b11;
 
 const LEGACY_ASSERT_ATTRIBUTES = Symbol("assert");
 
-/**
- * @param {any} Parser parser
- * @returns {typeof AcornParser} extender acorn parser
- */
-const importAssertions = Parser =>
-	/** @type {typeof AcornParser} */ (
-		/** @type {unknown} */ (
-			class extends Parser {
-				parseWithClause() {
-					const nodes = [];
-
-					const isAssertLegacy = this.value === "assert";
-
-					if (isAssertLegacy) {
-						if (!this.eat(tokTypes.name)) {
-							return nodes;
-						}
-					} else if (!this.eat(tokTypes._with)) {
-						return nodes;
-					}
-
-					this.expect(tokTypes.braceL);
+/** @type {(BaseParser: typeof AcornParser) => typeof AcornParser} */
+const importAssertions = (Parser) =>
+	class extends Parser {
+		/**
+		 * @this {InstanceType<AcornParser>}
+		 * @returns {ImportAttribute[]} import attributes
+		 */
+		parseWithClause() {
+			/** @type {ImportAttribute[]} */
+			const nodes = [];
 
-					const attributeKeys = {};
-					let first = true;
+			const isAssertLegacy = this.value === "assert";
 
-					while (!this.eat(tokTypes.braceR)) {
-						if (!first) {
-							this.expect(tokTypes.comma);
-							if (this.afterTrailingComma(tokTypes.braceR)) {
-								break;
-							}
-						} else {
-							first = false;
-						}
+			if (isAssertLegacy) {
+				if (!this.eat(tokTypes.name)) {
+					return nodes;
+				}
+			} else if (!this.eat(tokTypes._with)) {
+				return nodes;
+			}
 
-						const attr = this.parseImportAttribute();
-						const keyName =
-							attr.key.type === "Identifier" ? attr.key.name : attr.key.value;
+			this.expect(tokTypes.braceL);
 
-						if (Object.prototype.hasOwnProperty.call(attributeKeys, keyName)) {
-							this.raiseRecoverable(
-								attr.key.start,
-								`Duplicate attribute key '${keyName}'`
-							);
-						}
+			/** @type {Record<string, boolean>} */
+			const attributeKeys = {};
+			let first = true;
 
-						attributeKeys[keyName] = true;
-						nodes.push(attr);
+			while (!this.eat(tokTypes.braceR)) {
+				if (!first) {
+					this.expect(tokTypes.comma);
+					if (this.afterTrailingComma(tokTypes.braceR)) {
+						break;
 					}
+				} else {
+					first = false;
+				}
 
-					if (isAssertLegacy) {
-						nodes[LEGACY_ASSERT_ATTRIBUTES] = true;
-					}
+				const attr =
+					/** @type {ImportAttribute} */
+					this.parseImportAttribute();
+				const keyName =
+					attr.key.type === "Identifier" ? attr.key.name : attr.key.value;
 
-					return nodes;
+				if (Object.prototype.hasOwnProperty.call(attributeKeys, keyName)) {
+					this.raiseRecoverable(
+						attr.key.start,
+						`Duplicate attribute key '${keyName}'`
+					);
 				}
+
+				attributeKeys[keyName] = true;
+				nodes.push(attr);
 			}
-		)
-	);
+
+			if (isAssertLegacy) {
+				/** @type {EXPECTED_ANY} */
+				(nodes)[LEGACY_ASSERT_ATTRIBUTES] = true;
+			}
+
+			return nodes;
+		}
+	};
 
 // Syntax: https://developer.mozilla.org/en/SpiderMonkey/Parser_API
-const parser = AcornParser.extend(importAssertions);
+let parser = AcornParser.extend(importAssertions);
 
 /** @typedef {Record<string, string> & { _isLegacyAssert?: boolean }} ImportAttributes */
 
@@ -185,7 +207,7 @@ const parser = AcornParser.extend(importAssertions);
  * @param {ImportDeclaration | ExportNamedDeclaration | ExportAllDeclaration | ImportExpression} node node with assertions
  * @returns {ImportAttributes | undefined} import attributes
  */
-const getImportAttributes = node => {
+const getImportAttributes = (node) => {
 	if (node.type === "ImportExpression") {
 		if (
 			node.options &&
@@ -247,37 +269,107 @@ const getImportAttributes = node => {
 		result[key] = /** @type {string} */ (attribute.value.value);
 	}
 
-	if (node.attributes[LEGACY_ASSERT_ATTRIBUTES]) {
+	if (/** @type {EXPECTED_ANY} */ (node.attributes)[LEGACY_ASSERT_ATTRIBUTES]) {
 		result._isLegacyAssert = true;
 	}
 
 	return result;
 };
 
+/** @typedef {typeof VariableInfoFlags.Evaluated | typeof VariableInfoFlags.Free | typeof VariableInfoFlags.Normal | typeof VariableInfoFlags.Tagged} VariableInfoFlagsType */
+
+const VariableInfoFlags = Object.freeze({
+	Evaluated: 0b000,
+	Free: 0b001,
+	Normal: 0b010,
+	Tagged: 0b100
+});
+
 class VariableInfo {
 	/**
 	 * @param {ScopeInfo} declaredScope scope in which the variable is declared
-	 * @param {string | true | undefined} freeName which free name the variable aliases, or true when none
+	 * @param {string | undefined} name which name the variable use, defined name or free name or tagged name
+	 * @param {VariableInfoFlagsType} flags how the variable is created
 	 * @param {TagInfo | undefined} tagInfo info about tags
 	 */
-	constructor(declaredScope, freeName, tagInfo) {
+	constructor(declaredScope, name, flags, tagInfo) {
 		this.declaredScope = declaredScope;
-		this.freeName = freeName;
+		this.name = name;
+		this.flags = flags;
 		this.tagInfo = tagInfo;
 	}
+
+	/**
+	 * @returns {boolean} the variable is free or not
+	 */
+	isFree() {
+		return (this.flags & VariableInfoFlags.Free) > 0;
+	}
+
+	/**
+	 * @returns {boolean} the variable is tagged by tagVariable or not
+	 */
+	isTagged() {
+		return (this.flags & VariableInfoFlags.Tagged) > 0;
+	}
 }
 
 /** @typedef {string | ScopeInfo | VariableInfo} ExportedVariableInfo */
 /** @typedef {Literal | string | null | undefined} ImportSource */
-/** @typedef {Omit<AcornOptions, "sourceType" | "ecmaVersion"> & { sourceType: "module" | "script" | "auto", ecmaVersion?: AcornOptions["ecmaVersion"] }} ParseOptions */
+
+/**
+ * @typedef {Omit<ParseOptions, "sourceType"> & {sourceType: "module" | "script" | "auto"}} InternalParseOptions
+ */
+
+/**
+ * @typedef {object} ParseOptions
+ * @property {"module" | "script"} sourceType
+ * @property {EcmaVersion=} ecmaVersion
+ * @property {boolean=} locations
+ * @property {boolean=} comments
+ * @property {boolean=} ranges
+ * @property {boolean=} semicolons
+ * @property {boolean=} allowHashBang
+ * @property {boolean=} allowReturnOutsideFunction
+ */
+
+/**
+ * @typedef {object} ParseResult
+ * @property {Program} ast
+ * @property {Comment[]} comments
+ * @property {Set<number>} semicolons
+ */
+
+/**
+ * @typedef {(code: string, options: ParseOptions) => ParseResult} ParseFunction
+ */
+
+/** @typedef {symbol} Tag */
+
+/** @typedef {import("../dependencies/HarmonyImportDependencyParserPlugin").HarmonySettings} HarmonySettings */
+/** @typedef {import("../dependencies/ImportParserPlugin").ImportSettings} ImportSettings */
+/** @typedef {import("../dependencies/CommonJsImportsParserPlugin").CommonJsImportSettings} CommonJsImportSettings */
+/** @typedef {import("../CompatibilityPlugin").CompatibilitySettings} CompatibilitySettings */
+/** @typedef {import("../optimize/InnerGraph").TopLevelSymbol} TopLevelSymbol */
+
+/** @typedef {HarmonySettings | ImportSettings | CommonJsImportSettings | TopLevelSymbol | CompatibilitySettings} KnownTagData */
+/** @typedef {KnownTagData | Record<string, EXPECTED_ANY>} TagData */
 
 /**
  * @typedef {object} TagInfo
- * @property {any} tag
- * @property {any} data
+ * @property {Tag} tag
+ * @property {TagData=} data
  * @property {TagInfo | undefined} next
  */
 
+/** @typedef {string[]} CalleeMembers */
+/** @typedef {string[]} Members */
+/** @typedef {boolean[]} MembersOptionals */
+/** @typedef {Range[]} MemberRanges */
+
+const SCOPE_INFO_TERMINATED_RETURN = 1;
+const SCOPE_INFO_TERMINATED_THROW = 2;
+
 /**
  * @typedef {object} ScopeInfo
  * @property {StackedMap<string, VariableInfo | ScopeInfo>} definitions
@@ -287,6 +379,7 @@ class VariableInfo {
  * @property {boolean} inTry
  * @property {boolean} isStrict
  * @property {boolean} isAsmJs
+ * @property {undefined | 1 | 2} terminated
  */
 
 /** @typedef {[number, number]} Range */
@@ -294,7 +387,9 @@ class VariableInfo {
 /**
  * @typedef {object} DestructuringAssignmentProperty
  * @property {string} id
- * @property {Range | undefined=} range
+ * @property {Range} range
+ * @property {SourceLocation} loc
+ * @property {Set<DestructuringAssignmentProperty> | undefined=} pattern
  * @property {boolean | string} shorthand
  */
 
@@ -302,9 +397,9 @@ class VariableInfo {
  * 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
+ * @param {Range} startRange start range to join
+ * @param {Range} endRange end range to join
+ * @returns {Range} joined range
  * @example
  * ```js
  * 	const startRange = [0, 5];
@@ -323,7 +418,7 @@ const joinRanges = (startRange, endRange) => {
  * 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
+ * @param {Members} membersReversed reversed list of members
  * @returns {string} member expression as a string
  * @example
  * ```js
@@ -350,7 +445,7 @@ const objectAndMembersToName = (object, membersReversed) => {
  * @param {Expression | SpreadElement | Super} expression expression
  * @returns {string | "this" | undefined} name or variable info
  */
-const getRootName = expression => {
+const getRootName = (expression) => {
 	switch (expression.type) {
 		case "Identifier":
 			return expression.name;
@@ -363,15 +458,15 @@ const getRootName = expression => {
 	}
 };
 
-/** @type {AcornOptions} */
+/** @type {ParseOptions} */
 const defaultParserOptions = {
-	ranges: true,
-	locations: true,
-	ecmaVersion: "latest",
 	sourceType: "module",
+	ecmaVersion: "latest",
+	ranges: false,
+	locations: false,
+	comments: false,
 	// https://github.com/tc39/proposal-hashbang
-	allowHashBang: true,
-	onComment: undefined
+	allowHashBang: true
 };
 
 const EMPTY_COMMENT_OPTIONS = {
@@ -379,16 +474,19 @@ const EMPTY_COMMENT_OPTIONS = {
 	errors: null
 };
 
+const CLASS_NAME = "JavascriptParser";
+
 class JavascriptParser extends Parser {
 	/**
-	 * @param {"module" | "script" | "auto"} sourceType default source type
+	 * @param {"module" | "script" | "auto"=} sourceType default source type
+	 * @param {{ parse?: ParseFunction }=} options parser options
 	 */
-	constructor(sourceType = "auto") {
+	constructor(sourceType = "auto", options = {}) {
 		super();
 		this.hooks = Object.freeze({
 			/** @type {HookMap<SyncBailHook<[UnaryExpression], BasicEvaluatedExpression | null | undefined>>} */
 			evaluateTypeof: new HookMap(() => new SyncBailHook(["expression"])),
-			/** @type {HookMap<SyncBailHook<[Expression | SpreadElement | PrivateIdentifier], BasicEvaluatedExpression | null | undefined>>} */
+			/** @type {HookMap<SyncBailHook<[Expression | SpreadElement | PrivateIdentifier | Super], BasicEvaluatedExpression | null | undefined>>} */
 			evaluate: new HookMap(() => new SyncBailHook(["expression"])),
 			/** @type {HookMap<SyncBailHook<[Identifier | ThisExpression | MemberExpression | MetaProperty], BasicEvaluatedExpression | null | undefined>>} */
 			evaluateIdentifier: new HookMap(() => new SyncBailHook(["expression"])),
@@ -408,27 +506,27 @@ class JavascriptParser extends Parser {
 			evaluateCallExpressionMember: new HookMap(
 				() => new SyncBailHook(["expression", "param"])
 			),
-			/** @type {HookMap<SyncBailHook<[Expression | Declaration | PrivateIdentifier, number], boolean | void>>} */
+			/** @type {HookMap<SyncBailHook<[Expression | Declaration | PrivateIdentifier | MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration, number], boolean | void>>} */
 			isPure: new HookMap(
 				() => new SyncBailHook(["expression", "commentsStartPosition"])
 			),
-			/** @type {SyncBailHook<[Statement | ModuleDeclaration], boolean | void>} */
+			/** @type {SyncBailHook<[Statement | ModuleDeclaration | MaybeNamedClassDeclaration | MaybeNamedFunctionDeclaration], boolean | void>} */
 			preStatement: new SyncBailHook(["statement"]),
 
-			/** @type {SyncBailHook<[Statement | ModuleDeclaration], boolean | void>} */
+			/** @type {SyncBailHook<[Statement | ModuleDeclaration | MaybeNamedClassDeclaration | MaybeNamedFunctionDeclaration], boolean | void>} */
 			blockPreStatement: new SyncBailHook(["declaration"]),
-			/** @type {SyncBailHook<[Statement | ModuleDeclaration], boolean | void>} */
+			/** @type {SyncBailHook<[Statement | ModuleDeclaration | MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration], boolean | void>} */
 			statement: new SyncBailHook(["statement"]),
 			/** @type {SyncBailHook<[IfStatement], boolean | void>} */
 			statementIf: new SyncBailHook(["statement"]),
-			/** @type {SyncBailHook<[Expression, ClassExpression | ClassDeclaration], boolean | void>} */
+			/** @type {SyncBailHook<[Expression, ClassExpression | ClassDeclaration | MaybeNamedClassDeclaration], boolean | void>} */
 			classExtendsExpression: new SyncBailHook([
 				"expression",
 				"classDefinition"
 			]),
-			/** @type {SyncBailHook<[MethodDefinition | PropertyDefinition | StaticBlock, ClassExpression | ClassDeclaration], boolean | void>} */
+			/** @type {SyncBailHook<[MethodDefinition | PropertyDefinition | StaticBlock, ClassExpression | ClassDeclaration | MaybeNamedClassDeclaration], boolean | void>} */
 			classBodyElement: new SyncBailHook(["element", "classDefinition"]),
-			/** @type {SyncBailHook<[Expression, MethodDefinition | PropertyDefinition, ClassExpression | ClassDeclaration], boolean | void>} */
+			/** @type {SyncBailHook<[Expression, MethodDefinition | PropertyDefinition, ClassExpression | ClassDeclaration | MaybeNamedClassDeclaration], boolean | void>} */
 			classBodyValue: new SyncBailHook([
 				"expression",
 				"element",
@@ -451,8 +549,8 @@ class JavascriptParser extends Parser {
 			exportImport: new SyncBailHook(["statement", "source"]),
 			/** @type {SyncBailHook<[ExportDefaultDeclaration | ExportNamedDeclaration | ExportAllDeclaration, Declaration], boolean | void>} */
 			exportDeclaration: new SyncBailHook(["statement", "declaration"]),
-			/** @type {SyncBailHook<[ExportDefaultDeclaration, FunctionDeclaration | ClassDeclaration], boolean | void>} */
-			exportExpression: new SyncBailHook(["statement", "declaration"]),
+			/** @type {SyncBailHook<[ExportDefaultDeclaration, MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration | Expression], boolean | void>} */
+			exportExpression: new SyncBailHook(["statement", "node"]),
 			/** @type {SyncBailHook<[ExportDefaultDeclaration | ExportNamedDeclaration | ExportAllDeclaration, string, string, number | undefined], boolean | void>} */
 			exportSpecifier: new SyncBailHook([
 				"statement",
@@ -472,36 +570,42 @@ class JavascriptParser extends Parser {
 			preDeclarator: new SyncBailHook(["declarator", "statement"]),
 			/** @type {SyncBailHook<[VariableDeclarator, Statement], boolean | void>} */
 			declarator: new SyncBailHook(["declarator", "statement"]),
-			/** @type {HookMap<SyncBailHook<[Declaration], boolean | void>>} */
+			/** @type {HookMap<SyncBailHook<[Identifier], boolean | void>>} */
 			varDeclaration: new HookMap(() => new SyncBailHook(["declaration"])),
-			/** @type {HookMap<SyncBailHook<[Declaration], boolean | void>>} */
+			/** @type {HookMap<SyncBailHook<[Identifier], boolean | void>>} */
 			varDeclarationLet: new HookMap(() => new SyncBailHook(["declaration"])),
-			/** @type {HookMap<SyncBailHook<[Declaration], boolean | void>>} */
+			/** @type {HookMap<SyncBailHook<[Identifier], boolean | void>>} */
 			varDeclarationConst: new HookMap(() => new SyncBailHook(["declaration"])),
-			/** @type {HookMap<SyncBailHook<[Declaration], boolean | void>>} */
+			/** @type {HookMap<SyncBailHook<[Identifier], boolean | void>>} */
+			varDeclarationUsing: new HookMap(() => new SyncBailHook(["declaration"])),
+			/** @type {HookMap<SyncBailHook<[Identifier], boolean | void>>} */
 			varDeclarationVar: new HookMap(() => new SyncBailHook(["declaration"])),
 			/** @type {HookMap<SyncBailHook<[Identifier], boolean | void>>} */
 			pattern: new HookMap(() => new SyncBailHook(["pattern"])),
+			/** @type {SyncBailHook<[Expression], boolean | void>} */
+			collectDestructuringAssignmentProperties: new SyncBailHook([
+				"expression"
+			]),
 			/** @type {HookMap<SyncBailHook<[Expression], boolean | void>>} */
 			canRename: new HookMap(() => new SyncBailHook(["initExpression"])),
 			/** @type {HookMap<SyncBailHook<[Expression], boolean | void>>} */
 			rename: new HookMap(() => new SyncBailHook(["initExpression"])),
 			/** @type {HookMap<SyncBailHook<[AssignmentExpression], boolean | void>>} */
 			assign: new HookMap(() => new SyncBailHook(["expression"])),
-			/** @type {HookMap<SyncBailHook<[AssignmentExpression, string[]], boolean | void>>} */
+			/** @type {HookMap<SyncBailHook<[AssignmentExpression, Members], boolean | void>>} */
 			assignMemberChain: new HookMap(
 				() => new SyncBailHook(["expression", "members"])
 			),
 			/** @type {HookMap<SyncBailHook<[Expression], boolean | void>>} */
 			typeof: new HookMap(() => new SyncBailHook(["expression"])),
-			/** @type {SyncBailHook<[ImportExpression], boolean | void>} */
-			importCall: new SyncBailHook(["expression"]),
+			/** @type {SyncBailHook<[ImportExpression, CallExpression?], boolean | void>} */
+			importCall: new SyncBailHook(["expression", "importThen"]),
 			/** @type {SyncBailHook<[Expression | ForOfStatement], boolean | void>} */
 			topLevelAwait: new SyncBailHook(["expression"]),
 			/** @type {HookMap<SyncBailHook<[CallExpression], boolean | void>>} */
 			call: new HookMap(() => new SyncBailHook(["expression"])),
 			/** Something like "a.b()" */
-			/** @type {HookMap<SyncBailHook<[CallExpression, string[], boolean[], Range[]], boolean | void>>} */
+			/** @type {HookMap<SyncBailHook<[CallExpression, Members, MembersOptionals, MemberRanges], boolean | void>>} */
 			callMemberChain: new HookMap(
 				() =>
 					new SyncBailHook([
@@ -512,7 +616,7 @@ class JavascriptParser extends Parser {
 					])
 			),
 			/** Something like "a.b().c.d" */
-			/** @type {HookMap<SyncBailHook<[Expression, string[], CallExpression, string[], Range[]], boolean | void>>} */
+			/** @type {HookMap<SyncBailHook<[Expression, CalleeMembers, CallExpression, Members, MemberRanges], boolean | void>>} */
 			memberChainOfCallMemberChain: new HookMap(
 				() =>
 					new SyncBailHook([
@@ -524,7 +628,7 @@ class JavascriptParser extends Parser {
 					])
 			),
 			/** Something like "a.b().c.d()"" */
-			/** @type {HookMap<SyncBailHook<[CallExpression, string[], CallExpression, string[], Range[]], boolean | void>>} */
+			/** @type {HookMap<SyncBailHook<[CallExpression, CalleeMembers, CallExpression, Members, MemberRanges], boolean | void>>} */
 			callMemberChainOfCallMemberChain: new HookMap(
 				() =>
 					new SyncBailHook([
@@ -543,7 +647,7 @@ class JavascriptParser extends Parser {
 			binaryExpression: new SyncBailHook(["binaryExpression"]),
 			/** @type {HookMap<SyncBailHook<[Expression], boolean | void>>} */
 			expression: new HookMap(() => new SyncBailHook(["expression"])),
-			/** @type {HookMap<SyncBailHook<[MemberExpression, string[], boolean[], Range[]], boolean | void>>} */
+			/** @type {HookMap<SyncBailHook<[MemberExpression, Members, MembersOptionals, MemberRanges], boolean | void>>} */
 			expressionMemberChain: new HookMap(
 				() =>
 					new SyncBailHook([
@@ -553,7 +657,7 @@ class JavascriptParser extends Parser {
 						"memberRanges"
 					])
 			),
-			/** @type {HookMap<SyncBailHook<[MemberExpression, string[]], boolean | void>>} */
+			/** @type {HookMap<SyncBailHook<[MemberExpression, Members], boolean | void>>} */
 			unhandledExpressionMemberChain: new HookMap(
 				() => new SyncBailHook(["expression", "members"])
 			),
@@ -563,31 +667,38 @@ class JavascriptParser extends Parser {
 			expressionLogicalOperator: new SyncBailHook(["expression"]),
 			/** @type {SyncBailHook<[Program, Comment[]], boolean | void>} */
 			program: new SyncBailHook(["ast", "comments"]),
+			/** @type {SyncBailHook<[ThrowStatement | ReturnStatement], boolean | void>} */
+			terminate: new SyncBailHook(["statement"]),
 			/** @type {SyncBailHook<[Program, Comment[]], boolean | void>} */
-			finish: new SyncBailHook(["ast", "comments"])
+			finish: new SyncBailHook(["ast", "comments"]),
+			/** @type {SyncBailHook<[Statement], boolean | void>} */
+			unusedStatement: new SyncBailHook(["statement"])
 		});
 		this.sourceType = sourceType;
+		this.options = options;
+
 		/** @type {ScopeInfo} */
-		this.scope = undefined;
-		/** @type {ParserState} */
-		this.state = undefined;
+		this.scope = /** @type {EXPECTED_ANY} */ (undefined);
+		/** @type {JavascriptParserState} */
+		this.state = /** @type {EXPECTED_ANY} */ (undefined);
 		/** @type {Comment[] | undefined} */
 		this.comments = undefined;
 		/** @type {Set<number> | undefined} */
 		this.semicolons = undefined;
 		/** @type {StatementPath | undefined} */
 		this.statementPath = undefined;
-		/** @type {Statement | ModuleDeclaration | Expression | undefined} */
+		/** @type {Statement | ModuleDeclaration | Expression | MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration | undefined} */
 		this.prevStatement = undefined;
-		/** @type {WeakMap<Expression, Set<DestructuringAssignmentProperty>> | undefined} */
+		/** @type {WeakMap<Expression, DestructuringAssignmentProperties> | undefined} */
 		this.destructuringAssignmentProperties = undefined;
+		/** @type {TagData | undefined} */
 		this.currentTagData = undefined;
 		this.magicCommentContext = createMagicCommentContext();
 		this._initializeEvaluating();
 	}
 
 	_initializeEvaluating() {
-		this.hooks.evaluate.for("Literal").tap("JavascriptParser", _expr => {
+		this.hooks.evaluate.for("Literal").tap(CLASS_NAME, (_expr) => {
 			const expr = /** @type {Literal} */ (_expr);
 
 			switch (typeof expr.value) {
@@ -619,7 +730,7 @@ class JavascriptParser extends Parser {
 					.setRange(/** @type {Range} */ (expr.range));
 			}
 		});
-		this.hooks.evaluate.for("NewExpression").tap("JavascriptParser", _expr => {
+		this.hooks.evaluate.for("NewExpression").tap(CLASS_NAME, (_expr) => {
 			const expr = /** @type {NewExpression} */ (_expr);
 			const callee = expr.callee;
 			if (callee.type !== "Identifier") return;
@@ -632,8 +743,9 @@ class JavascriptParser extends Parser {
 			} else if (
 				expr.arguments.length > 2 ||
 				this.getVariableInfo("RegExp") !== "RegExp"
-			)
+			) {
 				return;
+			}
 
 			let regExp;
 			const arg1 = expr.arguments[0];
@@ -673,8 +785,9 @@ class JavascriptParser extends Parser {
 					if (
 						flags === undefined ||
 						!BasicEvaluatedExpression.isValidRegExpFlags(flags)
-					)
+					) {
 						return;
+					}
 				}
 			}
 
@@ -682,52 +795,55 @@ class JavascriptParser extends Parser {
 				.setRegExp(flags ? new RegExp(regExp, flags) : new RegExp(regExp))
 				.setRange(/** @type {Range} */ (expr.range));
 		});
-		this.hooks.evaluate
-			.for("LogicalExpression")
-			.tap("JavascriptParser", _expr => {
-				const expr = /** @type {LogicalExpression} */ (_expr);
-
-				const left = this.evaluateExpression(expr.left);
-				let returnRight = false;
-				/** @type {boolean | undefined} */
-				let allowedRight;
-				if (expr.operator === "&&") {
-					const leftAsBool = left.asBool();
-					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(/** @type {Range} */ (expr.range));
-					returnRight = leftAsBool === false;
-					allowedRight = true;
-				} else if (expr.operator === "??") {
-					const leftAsNullish = left.asNullish();
-					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 (returnRight) {
-					if (left.couldHaveSideEffects()) right.setSideEffects();
-					return right.setRange(/** @type {Range} */ (expr.range));
+		this.hooks.evaluate.for("LogicalExpression").tap(CLASS_NAME, (_expr) => {
+			const expr = /** @type {LogicalExpression} */ (_expr);
+
+			const left = this.evaluateExpression(expr.left);
+			let returnRight = false;
+			/** @type {boolean | undefined} */
+			let allowedRight;
+			if (expr.operator === "&&") {
+				const leftAsBool = left.asBool();
+				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(/** @type {Range} */ (expr.range));
+				}
+				returnRight = leftAsBool === false;
+				allowedRight = true;
+			} else if (expr.operator === "??") {
+				const leftAsNullish = left.asNullish();
+				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 (returnRight) {
+				if (left.couldHaveSideEffects()) right.setSideEffects();
+				return right.setRange(/** @type {Range} */ (expr.range));
+			}
 
-				const asBool = right.asBool();
+			const asBool = right.asBool();
 
-				if (allowedRight === true && asBool === true) {
-					return new BasicEvaluatedExpression()
-						.setRange(/** @type {Range} */ (expr.range))
-						.setTruthy();
-				} else if (allowedRight === false && asBool === false) {
-					return new BasicEvaluatedExpression()
-						.setRange(/** @type {Range} */ (expr.range))
-						.setFalsy();
-				}
-			});
+			if (allowedRight === true && asBool === true) {
+				return new BasicEvaluatedExpression()
+					.setRange(/** @type {Range} */ (expr.range))
+					.setTruthy();
+			} else if (allowedRight === false && asBool === false) {
+				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
@@ -797,550 +913,541 @@ class JavascriptParser extends Parser {
 			}
 		};
 
-		this.hooks.evaluate
-			.for("BinaryExpression")
-			.tap("JavascriptParser", _expr => {
-				const expr = /** @type {BinaryExpression} */ (_expr);
-
-				/**
-				 * Evaluates a binary expression if and only if it is a const operation (e.g. 1 + 2, "a" + "b", etc.).
-				 * @template T
-				 * @param {(leftOperand: T, rightOperand: T) => boolean | number | bigint | string} operandHandler the handler for the operation (e.g. (a, b) => a + b)
-				 * @returns {BasicEvaluatedExpression | undefined} the evaluated expression
-				 */
-				const handleConstOperation = operandHandler => {
-					const left = this.evaluateExpression(expr.left);
-					if (!left.isCompileTimeValue()) return;
+		this.hooks.evaluate.for("BinaryExpression").tap(CLASS_NAME, (_expr) => {
+			const expr = /** @type {BinaryExpression} */ (_expr);
 
-					const right = this.evaluateExpression(expr.right);
-					if (!right.isCompileTimeValue()) return;
+			/**
+			 * Evaluates a binary expression if and only if it is a const operation (e.g. 1 + 2, "a" + "b", etc.).
+			 * @template T
+			 * @param {(leftOperand: T, rightOperand: T) => boolean | number | bigint | string} operandHandler the handler for the operation (e.g. (a, b) => a + b)
+			 * @returns {BasicEvaluatedExpression | undefined} the evaluated expression
+			 */
+			const handleConstOperation = (operandHandler) => {
+				const left = this.evaluateExpression(expr.left);
+				if (!left.isCompileTimeValue()) return;
 
-					const result = operandHandler(
-						left.asCompileTimeValue(),
-						right.asCompileTimeValue()
-					);
-					return valueAsExpression(
-						result,
-						expr,
-						left.couldHaveSideEffects() || right.couldHaveSideEffects()
-					);
-				};
+				const right = this.evaluateExpression(expr.right);
+				if (!right.isCompileTimeValue()) return;
 
-				/**
-				 * 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);
+				const result = operandHandler(
+					/** @type {T} */ (left.asCompileTimeValue()),
+					/** @type {T} */ (right.asCompileTimeValue())
+				);
+				return valueAsExpression(
+					result,
+					expr,
+					left.couldHaveSideEffects() || right.couldHaveSideEffects()
+				);
+			};
 
+			/**
+			 * 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} left left
-				 * @param {BasicEvaluatedExpression} right right
-				 * @param {BasicEvaluatedExpression} res res
-				 * @param {boolean} eql true for "===" and false for "!=="
-				 * @returns {BasicEvaluatedExpression | undefined} result
+				 * @param {BasicEvaluatedExpression[]} parts parts
+				 * @returns {string} value
 				 */
-				const handleTemplateStringCompare = (left, right, res, eql) => {
-					/**
-					 * @param {BasicEvaluatedExpression[]} parts parts
-					 * @returns {string} value
-					 */
-					const getPrefix = parts => {
-						let value = "";
-						for (const p of parts) {
-							const v = p.asString();
-							if (v !== undefined) value += v;
-							else break;
-						}
-						return value;
-					};
-					/**
-					 * @param {BasicEvaluatedExpression[]} parts parts
-					 * @returns {string} value
-					 */
-					const getSuffix = parts => {
-						let value = "";
-						for (let i = parts.length - 1; i >= 0; i--) {
-							const v = parts[i].asString();
-							if (v !== undefined) value = v + value;
-							else break;
-						}
-						return value;
-					};
-					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);
-					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(
-								left.couldHaveSideEffects() || right.couldHaveSideEffects()
-							);
+				const getPrefix = (parts) => {
+					let value = "";
+					for (const p of parts) {
+						const v = p.asString();
+						if (v !== undefined) value += v;
+						else break;
 					}
+					return value;
 				};
-
 				/**
-				 * 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
+				 * @param {BasicEvaluatedExpression[]} parts parts
+				 * @returns {string} value
 				 */
-				const handleStrictEqualityComparison = eql => {
-					const left = this.evaluateExpression(expr.left);
-					const right = this.evaluateExpression(expr.right);
-					const res = new BasicEvaluatedExpression();
-					res.setRange(/** @type {Range} */ (expr.range));
-
-					const leftConst = left.isCompileTimeValue();
-					const rightConst = right.isCompileTimeValue();
-
-					if (leftConst && rightConst) {
-						return res
-							.setBoolean(
-								eql ===
-									(left.asCompileTimeValue() === right.asCompileTimeValue())
-							)
-							.setSideEffects(
-								left.couldHaveSideEffects() || right.couldHaveSideEffects()
-							);
+				const getSuffix = (parts) => {
+					let value = "";
+					for (let i = parts.length - 1; i >= 0; i--) {
+						const v = parts[i].asString();
+						if (v !== undefined) value = v + value;
+						else break;
 					}
+					return value;
+				};
+				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);
+				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(
+							left.couldHaveSideEffects() || right.couldHaveSideEffects()
+						);
+				}
+			};
 
-					if (left.isArray() && right.isArray()) {
-						return res
-							.setBoolean(!eql)
-							.setSideEffects(
-								left.couldHaveSideEffects() || right.couldHaveSideEffects()
-							);
-					}
-					if (left.isTemplateString() && right.isTemplateString()) {
-						return handleTemplateStringCompare(left, right, res, eql);
-					}
+			/**
+			 * Helper function to handle BinaryExpressions using strict equality comparisons (e.g. "===" and "!==").
+			 * @param {boolean} eql true for "===" and false for "!=="
+			 * @returns {BasicEvaluatedExpression | undefined} the evaluated expression
+			 */
+			const handleStrictEqualityComparison = (eql) => {
+				const left = this.evaluateExpression(expr.left);
+				const right = this.evaluateExpression(expr.right);
+				const res = new BasicEvaluatedExpression();
+				res.setRange(/** @type {Range} */ (expr.range));
 
-					const leftPrimitive = left.isPrimitiveType();
-					const rightPrimitive = right.isPrimitiveType();
+				const leftConst = left.isCompileTimeValue();
+				const rightConst = right.isCompileTimeValue();
 
-					if (
-						// Primitive !== Object or
-						// compile-time object types are never equal to something at runtime
-						(leftPrimitive === false &&
-							(leftConst || rightPrimitive === true)) ||
-						(rightPrimitive === false &&
-							(rightConst || leftPrimitive === true)) ||
-						// Different nullish or boolish status also means not equal
-						isAlwaysDifferent(
-							/** @type {boolean} */ (left.asBool()),
-							/** @type {boolean} */ (right.asBool())
-						) ||
-						isAlwaysDifferent(
-							/** @type {boolean} */ (left.asNullish()),
-							/** @type {boolean} */ (right.asNullish())
+				if (leftConst && rightConst) {
+					return res
+						.setBoolean(
+							eql === (left.asCompileTimeValue() === right.asCompileTimeValue())
 						)
-					) {
-						return res
-							.setBoolean(!eql)
-							.setSideEffects(
-								left.couldHaveSideEffects() || right.couldHaveSideEffects()
-							);
-					}
-				};
+						.setSideEffects(
+							left.couldHaveSideEffects() || right.couldHaveSideEffects()
+						);
+				}
 
-				/**
-				 * Helper function to handle BinaryExpressions using abstract equality comparisons (e.g. "==" and "!=").
-				 * @param {boolean} eql true for "==" and false for "!="
-				 * @returns {BasicEvaluatedExpression | undefined} the evaluated expression
-				 */
-				const handleAbstractEqualityComparison = eql => {
-					const left = this.evaluateExpression(expr.left);
-					const right = this.evaluateExpression(expr.right);
-					const res = new BasicEvaluatedExpression();
-					res.setRange(/** @type {Range} */ (expr.range));
-
-					const leftConst = left.isCompileTimeValue();
-					const rightConst = right.isCompileTimeValue();
-
-					if (leftConst && rightConst) {
-						return res
-							.setBoolean(
-								eql ===
-									// eslint-disable-next-line eqeqeq
-									(left.asCompileTimeValue() == right.asCompileTimeValue())
-							)
-							.setSideEffects(
-								left.couldHaveSideEffects() || right.couldHaveSideEffects()
-							);
-					}
+				if (left.isArray() && right.isArray()) {
+					return res
+						.setBoolean(!eql)
+						.setSideEffects(
+							left.couldHaveSideEffects() || right.couldHaveSideEffects()
+						);
+				}
+				if (left.isTemplateString() && right.isTemplateString()) {
+					return handleTemplateStringCompare(left, right, res, eql);
+				}
 
-					if (left.isArray() && right.isArray()) {
-						return res
-							.setBoolean(!eql)
-							.setSideEffects(
-								left.couldHaveSideEffects() || right.couldHaveSideEffects()
-							);
-					}
-					if (left.isTemplateString() && right.isTemplateString()) {
-						return handleTemplateStringCompare(left, right, res, eql);
-					}
-				};
+				const leftPrimitive = left.isPrimitiveType();
+				const rightPrimitive = right.isPrimitiveType();
 
-				if (expr.operator === "+") {
-					const left = this.evaluateExpression(expr.left);
-					const right = this.evaluateExpression(expr.right);
-					const res = new BasicEvaluatedExpression();
-					if (left.isString()) {
-						if (right.isString()) {
-							res.setString(
-								/** @type {string} */ (left.string) +
-									/** @type {string} */ (right.string)
-							);
-						} else if (right.isNumber()) {
-							res.setString(/** @type {string} */ (left.string) + right.number);
-						} else if (
-							right.isWrapped() &&
-							right.prefix &&
-							right.prefix.isString()
-						) {
-							// "left" + ("prefix" + inner + "postfix")
-							// => ("leftPrefix" + inner + "postfix")
-							res.setWrapped(
-								new BasicEvaluatedExpression()
-									.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
-							);
-						} else if (right.isWrapped()) {
-							// "left" + ([null] + inner + "postfix")
-							// => ("left" + inner + "postfix")
-							res.setWrapped(
-								left,
-								right.postfix,
-								right.wrappedInnerExpressions
-							);
-						} else {
-							// "left" + expr
-							// => ("left" + expr + "")
-							res.setWrapped(left, null, [right]);
-						}
-					} else if (left.isNumber()) {
-						if (right.isString()) {
-							res.setString(left.number + /** @type {string} */ (right.string));
-						} else if (right.isNumber()) {
-							res.setNumber(
-								/** @type {number} */ (left.number) +
-									/** @type {number} */ (right.number)
-							);
-						} else {
-							return;
-						}
-					} else if (left.isBigInt()) {
-						if (right.isBigInt()) {
-							res.setBigInt(
-								/** @type {bigint} */ (left.bigint) +
-									/** @type {bigint} */ (right.bigint)
-							);
-						}
-					} else if (left.isWrapped()) {
-						if (left.postfix && left.postfix.isString() && right.isString()) {
-							// ("prefix" + inner + "postfix") + "right"
-							// => ("prefix" + inner + "postfixRight")
-							res.setWrapped(
-								left.prefix,
-								new BasicEvaluatedExpression()
-									.setString(
-										/** @type {string} */ (left.postfix.string) +
-											/** @type {string} */ (right.string)
+				if (
+					// Primitive !== Object or
+					// compile-time object types are never equal to something at runtime
+					(leftPrimitive === false && (leftConst || rightPrimitive === true)) ||
+					(rightPrimitive === false &&
+						(rightConst || leftPrimitive === true)) ||
+					// Different nullish or boolish status also means not equal
+					isAlwaysDifferent(
+						/** @type {boolean} */ (left.asBool()),
+						/** @type {boolean} */ (right.asBool())
+					) ||
+					isAlwaysDifferent(
+						/** @type {boolean} */ (left.asNullish()),
+						/** @type {boolean} */ (right.asNullish())
+					)
+				) {
+					return res
+						.setBoolean(!eql)
+						.setSideEffects(
+							left.couldHaveSideEffects() || right.couldHaveSideEffects()
+						);
+				}
+			};
+
+			/**
+			 * Helper function to handle BinaryExpressions using abstract equality comparisons (e.g. "==" and "!=").
+			 * @param {boolean} eql true for "==" and false for "!="
+			 * @returns {BasicEvaluatedExpression | undefined} the evaluated expression
+			 */
+			const handleAbstractEqualityComparison = (eql) => {
+				const left = this.evaluateExpression(expr.left);
+				const right = this.evaluateExpression(expr.right);
+				const res = new BasicEvaluatedExpression();
+				res.setRange(/** @type {Range} */ (expr.range));
+
+				const leftConst = left.isCompileTimeValue();
+				const rightConst = right.isCompileTimeValue();
+
+				if (leftConst && rightConst) {
+					return res
+						.setBoolean(
+							eql ===
+								// eslint-disable-next-line eqeqeq
+								(left.asCompileTimeValue() == right.asCompileTimeValue())
+						)
+						.setSideEffects(
+							left.couldHaveSideEffects() || right.couldHaveSideEffects()
+						);
+				}
+
+				if (left.isArray() && right.isArray()) {
+					return res
+						.setBoolean(!eql)
+						.setSideEffects(
+							left.couldHaveSideEffects() || right.couldHaveSideEffects()
+						);
+				}
+				if (left.isTemplateString() && right.isTemplateString()) {
+					return handleTemplateStringCompare(left, right, res, eql);
+				}
+			};
+
+			if (expr.operator === "+") {
+				const left = this.evaluateExpression(expr.left);
+				const right = this.evaluateExpression(expr.right);
+				const res = new BasicEvaluatedExpression();
+				if (left.isString()) {
+					if (right.isString()) {
+						res.setString(
+							/** @type {string} */ (left.string) +
+								/** @type {string} */ (right.string)
+						);
+					} else if (right.isNumber()) {
+						res.setString(/** @type {string} */ (left.string) + right.number);
+					} else if (
+						right.isWrapped() &&
+						right.prefix &&
+						right.prefix.isString()
+					) {
+						// "left" + ("prefix" + inner + "postfix")
+						// => ("leftPrefix" + inner + "postfix")
+						res.setWrapped(
+							new BasicEvaluatedExpression()
+								.setString(
+									/** @type {string} */ (left.string) +
+										/** @type {string} */ (right.prefix.string)
+								)
+								.setRange(
+									joinRanges(
+										/** @type {Range} */ (left.range),
+										/** @type {Range} */ (right.prefix.range)
 									)
-									.setRange(
-										joinRanges(
-											/** @type {Range} */ (left.postfix.range),
-											/** @type {Range} */ (right.range)
-										)
-									),
-								left.wrappedInnerExpressions
-							);
-						} else if (
-							left.postfix &&
-							left.postfix.isString() &&
-							right.isNumber()
-						) {
-							// ("prefix" + inner + "postfix") + 123
-							// => ("prefix" + inner + "postfix123")
-							res.setWrapped(
-								left.prefix,
-								new BasicEvaluatedExpression()
-									.setString(
-										/** @type {string} */ (left.postfix.string) +
-											/** @type {number} */ (right.number)
+								),
+							right.postfix,
+							right.wrappedInnerExpressions
+						);
+					} else if (right.isWrapped()) {
+						// "left" + ([null] + inner + "postfix")
+						// => ("left" + inner + "postfix")
+						res.setWrapped(left, right.postfix, right.wrappedInnerExpressions);
+					} else {
+						// "left" + expr
+						// => ("left" + expr + "")
+						res.setWrapped(left, null, [right]);
+					}
+				} else if (left.isNumber()) {
+					if (right.isString()) {
+						res.setString(left.number + /** @type {string} */ (right.string));
+					} else if (right.isNumber()) {
+						res.setNumber(
+							/** @type {number} */ (left.number) +
+								/** @type {number} */ (right.number)
+						);
+					} else {
+						return;
+					}
+				} else if (left.isBigInt()) {
+					if (right.isBigInt()) {
+						res.setBigInt(
+							/** @type {bigint} */ (left.bigint) +
+								/** @type {bigint} */ (right.bigint)
+						);
+					}
+				} else if (left.isWrapped()) {
+					if (left.postfix && left.postfix.isString() && right.isString()) {
+						// ("prefix" + inner + "postfix") + "right"
+						// => ("prefix" + inner + "postfixRight")
+						res.setWrapped(
+							left.prefix,
+							new BasicEvaluatedExpression()
+								.setString(
+									/** @type {string} */ (left.postfix.string) +
+										/** @type {string} */ (right.string)
+								)
+								.setRange(
+									joinRanges(
+										/** @type {Range} */ (left.postfix.range),
+										/** @type {Range} */ (right.range)
 									)
-									.setRange(
-										joinRanges(
-											/** @type {Range} */ (left.postfix.range),
-											/** @type {Range} */ (right.range)
-										)
-									),
-								left.wrappedInnerExpressions
-							);
-						} else if (right.isString()) {
-							// ("prefix" + inner + [null]) + "right"
-							// => ("prefix" + inner + "right")
-							res.setWrapped(left.prefix, right, left.wrappedInnerExpressions);
-						} else if (right.isNumber()) {
-							// ("prefix" + inner + [null]) + 123
-							// => ("prefix" + inner + "123")
-							res.setWrapped(
-								left.prefix,
-								new BasicEvaluatedExpression()
-									.setString(String(right.number))
-									.setRange(/** @type {Range} */ (right.range)),
-								left.wrappedInnerExpressions
-							);
-						} else if (right.isWrapped()) {
-							// ("prefix1" + inner1 + "postfix1") + ("prefix2" + inner2 + "postfix2")
-							// ("prefix1" + inner1 + "postfix1" + "prefix2" + inner2 + "postfix2")
-							res.setWrapped(
-								left.prefix,
-								right.postfix,
-								left.wrappedInnerExpressions &&
-									right.wrappedInnerExpressions &&
-									left.wrappedInnerExpressions
-										.concat(left.postfix ? [left.postfix] : [])
-										.concat(right.prefix ? [right.prefix] : [])
-										.concat(right.wrappedInnerExpressions)
-							);
-						} else {
-							// ("prefix" + inner + postfix) + expr
-							// => ("prefix" + inner + postfix + expr + [null])
-							res.setWrapped(
-								left.prefix,
-								null,
-								left.wrappedInnerExpressions &&
-									left.wrappedInnerExpressions.concat(
-										left.postfix ? [left.postfix, right] : [right]
+								),
+							left.wrappedInnerExpressions
+						);
+					} else if (
+						left.postfix &&
+						left.postfix.isString() &&
+						right.isNumber()
+					) {
+						// ("prefix" + inner + "postfix") + 123
+						// => ("prefix" + inner + "postfix123")
+						res.setWrapped(
+							left.prefix,
+							new BasicEvaluatedExpression()
+								.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()) {
-						// left + "right"
-						// => ([null] + left + "right")
-						res.setWrapped(null, right, [left]);
+						// ("prefix" + inner + [null]) + "right"
+						// => ("prefix" + inner + "right")
+						res.setWrapped(left.prefix, right, left.wrappedInnerExpressions);
+					} else if (right.isNumber()) {
+						// ("prefix" + inner + [null]) + 123
+						// => ("prefix" + inner + "123")
+						res.setWrapped(
+							left.prefix,
+							new BasicEvaluatedExpression()
+								.setString(String(right.number))
+								.setRange(/** @type {Range} */ (right.range)),
+							left.wrappedInnerExpressions
+						);
 					} else if (right.isWrapped()) {
-						// left + (prefix + inner + "postfix")
-						// => ([null] + left + prefix + inner + "postfix")
+						// ("prefix1" + inner1 + "postfix1") + ("prefix2" + inner2 + "postfix2")
+						// ("prefix1" + inner1 + "postfix1" + "prefix2" + inner2 + "postfix2")
 						res.setWrapped(
-							null,
+							left.prefix,
 							right.postfix,
-							right.wrappedInnerExpressions &&
-								(right.prefix ? [left, right.prefix] : [left]).concat(
-									right.wrappedInnerExpressions
-								)
+							left.wrappedInnerExpressions &&
+								right.wrappedInnerExpressions && [
+									...left.wrappedInnerExpressions,
+									...(left.postfix ? [left.postfix] : []),
+									...(right.prefix ? [right.prefix] : []),
+									...right.wrappedInnerExpressions
+								]
 						);
 					} else {
-						return;
+						// ("prefix" + inner + postfix) + expr
+						// => ("prefix" + inner + postfix + expr + [null])
+						res.setWrapped(
+							left.prefix,
+							null,
+							left.wrappedInnerExpressions && [
+								...left.wrappedInnerExpressions,
+								...(left.postfix ? [left.postfix, right] : [right])
+							]
+						);
 					}
-					if (left.couldHaveSideEffects() || right.couldHaveSideEffects())
-						res.setSideEffects();
-					res.setRange(/** @type {Range} */ (expr.range));
-					return res;
-				} else if (expr.operator === "-") {
-					return handleConstOperation((l, r) => l - r);
-				} else if (expr.operator === "*") {
-					return handleConstOperation((l, r) => l * r);
-				} else if (expr.operator === "/") {
-					return handleConstOperation((l, r) => l / r);
-				} else if (expr.operator === "**") {
-					return handleConstOperation((l, r) => l ** r);
-				} else if (expr.operator === "===") {
-					return handleStrictEqualityComparison(true);
-				} else if (expr.operator === "==") {
-					return handleAbstractEqualityComparison(true);
-				} else if (expr.operator === "!==") {
-					return handleStrictEqualityComparison(false);
-				} else if (expr.operator === "!=") {
-					return handleAbstractEqualityComparison(false);
-				} else if (expr.operator === "&") {
-					return handleConstOperation((l, r) => l & r);
-				} else if (expr.operator === "|") {
-					return handleConstOperation((l, r) => l | r);
-				} else if (expr.operator === "^") {
-					return handleConstOperation((l, r) => l ^ r);
-				} else if (expr.operator === ">>>") {
-					return handleConstOperation((l, r) => l >>> r);
-				} else if (expr.operator === ">>") {
-					return handleConstOperation((l, r) => l >> r);
-				} else if (expr.operator === "<<") {
-					return handleConstOperation((l, r) => l << r);
-				} else if (expr.operator === "<") {
-					return handleConstOperation((l, r) => l < r);
-				} else if (expr.operator === ">") {
-					return handleConstOperation((l, r) => l > r);
-				} else if (expr.operator === "<=") {
-					return handleConstOperation((l, r) => l <= r);
-				} else if (expr.operator === ">=") {
-					return handleConstOperation((l, r) => l >= r);
-				}
-			});
-		this.hooks.evaluate
-			.for("UnaryExpression")
-			.tap("JavascriptParser", _expr => {
-				const expr = /** @type {UnaryExpression} */ (_expr);
-
-				/**
-				 * Evaluates a UnaryExpression if and only if it is a basic const operator (e.g. +a, -a, ~a).
-				 * @template T
-				 * @param {(operand: T) => boolean | number | bigint | string} operandHandler handler for the operand
-				 * @returns {BasicEvaluatedExpression | undefined} evaluated expression
-				 */
-				const handleConstOperation = operandHandler => {
-					const argument = this.evaluateExpression(expr.argument);
-					if (!argument.isCompileTimeValue()) return;
-					const result = operandHandler(argument.asCompileTimeValue());
-					return valueAsExpression(
-						result,
-						expr,
-						argument.couldHaveSideEffects()
+				} 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]),
+							...right.wrappedInnerExpressions
+						]
 					);
-				};
+				} else {
+					return;
+				}
+				if (left.couldHaveSideEffects() || right.couldHaveSideEffects()) {
+					res.setSideEffects();
+				}
+				res.setRange(/** @type {Range} */ (expr.range));
+				return res;
+			} else if (expr.operator === "-") {
+				return handleConstOperation((l, r) => l - r);
+			} else if (expr.operator === "*") {
+				return handleConstOperation((l, r) => l * r);
+			} else if (expr.operator === "/") {
+				return handleConstOperation((l, r) => l / r);
+			} else if (expr.operator === "**") {
+				return handleConstOperation((l, r) => l ** r);
+			} else if (expr.operator === "===") {
+				return handleStrictEqualityComparison(true);
+			} else if (expr.operator === "==") {
+				return handleAbstractEqualityComparison(true);
+			} else if (expr.operator === "!==") {
+				return handleStrictEqualityComparison(false);
+			} else if (expr.operator === "!=") {
+				return handleAbstractEqualityComparison(false);
+			} else if (expr.operator === "&") {
+				return handleConstOperation((l, r) => l & r);
+			} else if (expr.operator === "|") {
+				return handleConstOperation((l, r) => l | r);
+			} else if (expr.operator === "^") {
+				return handleConstOperation((l, r) => l ^ r);
+			} else if (expr.operator === ">>>") {
+				return handleConstOperation((l, r) => l >>> r);
+			} else if (expr.operator === ">>") {
+				return handleConstOperation((l, r) => l >> r);
+			} else if (expr.operator === "<<") {
+				return handleConstOperation((l, r) => l << r);
+			} else if (expr.operator === "<") {
+				return handleConstOperation((l, r) => l < r);
+			} else if (expr.operator === ">") {
+				return handleConstOperation((l, r) => l > r);
+			} else if (expr.operator === "<=") {
+				return handleConstOperation((l, r) => l <= r);
+			} else if (expr.operator === ">=") {
+				return handleConstOperation((l, r) => l >= r);
+			}
+		});
+		this.hooks.evaluate.for("UnaryExpression").tap(CLASS_NAME, (_expr) => {
+			const expr = /** @type {UnaryExpression} */ (_expr);
+
+			/**
+			 * Evaluates a UnaryExpression if and only if it is a basic const operator (e.g. +a, -a, ~a).
+			 * @template T
+			 * @param {(operand: T) => boolean | number | bigint | string} operandHandler handler for the operand
+			 * @returns {BasicEvaluatedExpression | undefined} evaluated expression
+			 */
+			const handleConstOperation = (operandHandler) => {
+				const argument = this.evaluateExpression(expr.argument);
+				if (!argument.isCompileTimeValue()) return;
+				const result = operandHandler(
+					/** @type {T} */ (argument.asCompileTimeValue())
+				);
+				return valueAsExpression(result, expr, argument.couldHaveSideEffects());
+			};
 
-				if (expr.operator === "typeof") {
-					switch (expr.argument.type) {
-						case "Identifier": {
-							const res = this.callHooksForName(
-								this.hooks.evaluateTypeof,
-								expr.argument.name,
-								expr
-							);
-							if (res !== undefined) return res;
-							break;
-						}
-						case "MetaProperty": {
-							const res = this.callHooksForName(
-								this.hooks.evaluateTypeof,
-								/** @type {string} */ (getRootName(expr.argument)),
-								expr
-							);
-							if (res !== undefined) return res;
-							break;
-						}
-						case "MemberExpression": {
-							const res = this.callHooksForExpression(
-								this.hooks.evaluateTypeof,
-								expr.argument,
-								expr
-							);
-							if (res !== undefined) return res;
-							break;
-						}
-						case "ChainExpression": {
-							const res = this.callHooksForExpression(
-								this.hooks.evaluateTypeof,
-								expr.argument.expression,
-								expr
-							);
-							if (res !== undefined) return res;
-							break;
-						}
-						case "FunctionExpression": {
-							return new BasicEvaluatedExpression()
-								.setString("function")
-								.setRange(/** @type {Range} */ (expr.range));
-						}
-					}
-					const arg = this.evaluateExpression(expr.argument);
-					if (arg.isUnknown()) return;
-					if (arg.isString()) {
-						return new BasicEvaluatedExpression()
-							.setString("string")
-							.setRange(/** @type {Range} */ (expr.range));
-					}
-					if (arg.isWrapped()) {
-						return new BasicEvaluatedExpression()
-							.setString("string")
-							.setSideEffects()
-							.setRange(/** @type {Range} */ (expr.range));
-					}
-					if (arg.isUndefined()) {
-						return new BasicEvaluatedExpression()
-							.setString("undefined")
-							.setRange(/** @type {Range} */ (expr.range));
-					}
-					if (arg.isNumber()) {
-						return new BasicEvaluatedExpression()
-							.setString("number")
-							.setRange(/** @type {Range} */ (expr.range));
+			if (expr.operator === "typeof") {
+				switch (expr.argument.type) {
+					case "Identifier": {
+						const res = this.callHooksForName(
+							this.hooks.evaluateTypeof,
+							expr.argument.name,
+							expr
+						);
+						if (res !== undefined) return res;
+						break;
 					}
-					if (arg.isBigInt()) {
-						return new BasicEvaluatedExpression()
-							.setString("bigint")
-							.setRange(/** @type {Range} */ (expr.range));
+					case "MetaProperty": {
+						const res = this.callHooksForName(
+							this.hooks.evaluateTypeof,
+							/** @type {string} */
+							(getRootName(expr.argument)),
+							expr
+						);
+						if (res !== undefined) return res;
+						break;
 					}
-					if (arg.isBoolean()) {
-						return new BasicEvaluatedExpression()
-							.setString("boolean")
-							.setRange(/** @type {Range} */ (expr.range));
+					case "MemberExpression": {
+						const res = this.callHooksForExpression(
+							this.hooks.evaluateTypeof,
+							expr.argument,
+							expr
+						);
+						if (res !== undefined) return res;
+						break;
 					}
-					if (arg.isConstArray() || arg.isRegExp() || arg.isNull()) {
-						return new BasicEvaluatedExpression()
-							.setString("object")
-							.setRange(/** @type {Range} */ (expr.range));
+					case "ChainExpression": {
+						const res = this.callHooksForExpression(
+							this.hooks.evaluateTypeof,
+							expr.argument.expression,
+							expr
+						);
+						if (res !== undefined) return res;
+						break;
 					}
-					if (arg.isArray()) {
+					case "FunctionExpression": {
 						return new BasicEvaluatedExpression()
-							.setString("object")
-							.setSideEffects(arg.couldHaveSideEffects())
+							.setString("function")
 							.setRange(/** @type {Range} */ (expr.range));
 					}
-				} else if (expr.operator === "!") {
-					const argument = this.evaluateExpression(expr.argument);
-					const bool = argument.asBool();
-					if (typeof bool !== "boolean") return;
+				}
+				const arg = this.evaluateExpression(expr.argument);
+				if (arg.isUnknown()) return;
+				if (arg.isString()) {
 					return new BasicEvaluatedExpression()
-						.setBoolean(!bool)
-						.setSideEffects(argument.couldHaveSideEffects())
+						.setString("string")
 						.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);
 				}
-			});
+				if (arg.isWrapped()) {
+					return new BasicEvaluatedExpression()
+						.setString("string")
+						.setSideEffects()
+						.setRange(/** @type {Range} */ (expr.range));
+				}
+				if (arg.isUndefined()) {
+					return new BasicEvaluatedExpression()
+						.setString("undefined")
+						.setRange(/** @type {Range} */ (expr.range));
+				}
+				if (arg.isNumber()) {
+					return new BasicEvaluatedExpression()
+						.setString("number")
+						.setRange(/** @type {Range} */ (expr.range));
+				}
+				if (arg.isBigInt()) {
+					return new BasicEvaluatedExpression()
+						.setString("bigint")
+						.setRange(/** @type {Range} */ (expr.range));
+				}
+				if (arg.isBoolean()) {
+					return new BasicEvaluatedExpression()
+						.setString("boolean")
+						.setRange(/** @type {Range} */ (expr.range));
+				}
+				if (arg.isConstArray() || arg.isRegExp() || arg.isNull()) {
+					return new BasicEvaluatedExpression()
+						.setString("object")
+						.setRange(/** @type {Range} */ (expr.range));
+				}
+				if (arg.isArray()) {
+					return new BasicEvaluatedExpression()
+						.setString("object")
+						.setSideEffects(arg.couldHaveSideEffects())
+						.setRange(/** @type {Range} */ (expr.range));
+				}
+			} else if (expr.operator === "!") {
+				const argument = this.evaluateExpression(expr.argument);
+				const bool = argument.asBool();
+				if (typeof bool !== "boolean") return;
+				return new BasicEvaluatedExpression()
+					.setBoolean(!bool)
+					.setSideEffects(argument.couldHaveSideEffects())
+					.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 =>
+			.tap(CLASS_NAME, (expr) =>
 				new BasicEvaluatedExpression()
 					.setString("undefined")
 					.setRange(/** @type {Range} */ (expr.range))
 			);
-		this.hooks.evaluate.for("Identifier").tap("JavascriptParser", expr => {
+		this.hooks.evaluate.for("Identifier").tap(CLASS_NAME, (expr) => {
 			if (/** @type {Identifier} */ (expr).name === "undefined") {
 				return new BasicEvaluatedExpression()
 					.setUndefined()
@@ -1349,7 +1456,7 @@ class JavascriptParser extends Parser {
 		});
 		/**
 		 * @param {"Identifier" | "ThisExpression" | "MemberExpression"} exprType expression type name
-		 * @param {function(Expression | SpreadElement): GetInfoResult | undefined} getInfo get info
+		 * @param {(node: Expression | SpreadElement) => GetInfoResult | undefined} getInfo get info
 		 * @returns {void}
 		 */
 		const tapEvaluateWithVariableInfo = (exprType, getInfo) => {
@@ -1357,7 +1464,7 @@ class JavascriptParser extends Parser {
 			let cachedExpression;
 			/** @type {GetInfoResult | undefined} */
 			let cachedInfo;
-			this.hooks.evaluate.for(exprType).tap("JavascriptParser", expr => {
+			this.hooks.evaluate.for(exprType).tap(CLASS_NAME, (expr) => {
 				const expression =
 					/** @type {Identifier | ThisExpression | MemberExpression} */ (expr);
 
@@ -1366,11 +1473,12 @@ class JavascriptParser extends Parser {
 					return this.callHooksForInfoWithFallback(
 						this.hooks.evaluateIdentifier,
 						info.name,
-						name => {
+						(_name) => {
 							cachedExpression = expression;
 							cachedInfo = info;
+							return undefined;
 						},
-						name => {
+						(name) => {
 							const hook = this.hooks.evaluateDefinedIdentifier.get(name);
 							if (hook !== undefined) {
 								return hook.call(expression);
@@ -1382,7 +1490,7 @@ class JavascriptParser extends Parser {
 			});
 			this.hooks.evaluate
 				.for(exprType)
-				.tap({ name: "JavascriptParser", stage: 100 }, expr => {
+				.tap({ name: CLASS_NAME, stage: 100 }, (expr) => {
 					const expression =
 						/** @type {Identifier | ThisExpression | MemberExpression} */
 						(expr);
@@ -1400,16 +1508,16 @@ class JavascriptParser extends Parser {
 							.setRange(/** @type {Range} */ (expression.range));
 					}
 				});
-			this.hooks.finish.tap("JavascriptParser", () => {
+			this.hooks.finish.tap(CLASS_NAME, () => {
 				// Cleanup for GC
 				cachedExpression = cachedInfo = undefined;
 			});
 		};
-		tapEvaluateWithVariableInfo("Identifier", expr => {
+		tapEvaluateWithVariableInfo("Identifier", (expr) => {
 			const info = this.getVariableInfo(/** @type {Identifier} */ (expr).name);
 			if (
 				typeof info === "string" ||
-				(info instanceof VariableInfo && typeof info.freeName === "string")
+				(info instanceof VariableInfo && (info.isFree() || info.isTagged()))
 			) {
 				return {
 					name: info,
@@ -1420,11 +1528,11 @@ class JavascriptParser extends Parser {
 				};
 			}
 		});
-		tapEvaluateWithVariableInfo("ThisExpression", expr => {
+		tapEvaluateWithVariableInfo("ThisExpression", (_expr) => {
 			const info = this.getVariableInfo("this");
 			if (
 				typeof info === "string" ||
-				(info instanceof VariableInfo && typeof info.freeName === "string")
+				(info instanceof VariableInfo && (info.isFree() || info.isTagged()))
 			) {
 				return {
 					name: info,
@@ -1435,23 +1543,24 @@ class JavascriptParser extends Parser {
 				};
 			}
 		});
-		this.hooks.evaluate.for("MetaProperty").tap("JavascriptParser", expr => {
+		this.hooks.evaluate.for("MetaProperty").tap(CLASS_NAME, (expr) => {
 			const metaProperty = /** @type {MetaProperty} */ (expr);
 
 			return this.callHooksForName(
 				this.hooks.evaluateIdentifier,
-				/** @type {string} */ (getRootName(metaProperty)),
+				/** @type {string} */
+				(getRootName(metaProperty)),
 				metaProperty
 			);
 		});
-		tapEvaluateWithVariableInfo("MemberExpression", expr =>
+		tapEvaluateWithVariableInfo("MemberExpression", (expr) =>
 			this.getMemberExpressionInfo(
 				/** @type {MemberExpression} */ (expr),
 				ALLOWED_MEMBER_TYPES_EXPRESSION
 			)
 		);
 
-		this.hooks.evaluate.for("CallExpression").tap("JavascriptParser", _expr => {
+		this.hooks.evaluate.for("CallExpression").tap(CLASS_NAME, (_expr) => {
 			const expr = /** @type {CallExpression} */ (_expr);
 			if (
 				expr.callee.type === "MemberExpression" &&
@@ -1480,7 +1589,7 @@ class JavascriptParser extends Parser {
 		});
 		this.hooks.evaluateCallExpressionMember
 			.for("indexOf")
-			.tap("JavascriptParser", (expr, param) => {
+			.tap(CLASS_NAME, (expr, param) => {
 				if (!param.isString()) return;
 				if (expr.arguments.length === 0) return;
 				const [arg1, arg2] = expr.arguments;
@@ -1508,7 +1617,7 @@ class JavascriptParser extends Parser {
 			});
 		this.hooks.evaluateCallExpressionMember
 			.for("replace")
-			.tap("JavascriptParser", (expr, param) => {
+			.tap(CLASS_NAME, (expr, param) => {
 				if (!param.isString()) return;
 				if (expr.arguments.length !== 2) return;
 				if (expr.arguments[0].type === "SpreadElement") return;
@@ -1531,7 +1640,7 @@ class JavascriptParser extends Parser {
 		for (const fn of ["substr", "substring", "slice"]) {
 			this.hooks.evaluateCallExpressionMember
 				.for(fn)
-				.tap("JavascriptParser", (expr, param) => {
+				.tap(CLASS_NAME, (expr, param) => {
 					if (!param.isString()) return;
 					let arg1;
 					let result;
@@ -1623,22 +1732,20 @@ class JavascriptParser extends Parser {
 			};
 		};
 
-		this.hooks.evaluate
-			.for("TemplateLiteral")
-			.tap("JavascriptParser", _node => {
-				const node = /** @type {TemplateLiteral} */ (_node);
+		this.hooks.evaluate.for("TemplateLiteral").tap(CLASS_NAME, (_node) => {
+			const node = /** @type {TemplateLiteral} */ (_node);
 
-				const { quasis, parts } = getSimplifiedTemplateResult("cooked", node);
-				if (parts.length === 1) {
-					return parts[0].setRange(/** @type {Range} */ (node.range));
-				}
-				return new BasicEvaluatedExpression()
-					.setTemplateString(quasis, parts, "cooked")
-					.setRange(/** @type {Range} */ (node.range));
-			});
+			const { quasis, parts } = getSimplifiedTemplateResult("cooked", node);
+			if (parts.length === 1) {
+				return parts[0].setRange(/** @type {Range} */ (node.range));
+			}
+			return new BasicEvaluatedExpression()
+				.setTemplateString(quasis, parts, "cooked")
+				.setRange(/** @type {Range} */ (node.range));
+		});
 		this.hooks.evaluate
 			.for("TaggedTemplateExpression")
-			.tap("JavascriptParser", _node => {
+			.tap(CLASS_NAME, (_node) => {
 				const node = /** @type {TaggedTemplateExpression} */ (_node);
 				const tag = this.evaluateExpression(node.tag);
 
@@ -1655,10 +1762,11 @@ class JavascriptParser extends Parser {
 
 		this.hooks.evaluateCallExpressionMember
 			.for("concat")
-			.tap("JavascriptParser", (expr, param) => {
+			.tap(CLASS_NAME, (expr, param) => {
 				if (!param.isString() && !param.isWrapped()) return;
 				let stringSuffix = null;
 				let hasUnknownParams = false;
+				/** @type {BasicEvaluatedExpression[]} */
 				const innerExpressions = [];
 				for (let i = expr.arguments.length - 1; i >= 0; i--) {
 					const arg = expr.arguments[i];
@@ -1673,13 +1781,14 @@ class JavascriptParser extends Parser {
 						continue;
 					}
 
-					/** @type {string} */
 					const value = argExpr.isString()
 						? /** @type {string} */ (argExpr.string)
-						: String(/** @type {number} */ (argExpr.number));
+						: String(argExpr.number);
 
 					/** @type {string} */
-					const newString = value + (stringSuffix ? stringSuffix.string : "");
+					const newString =
+						value +
+						(stringSuffix ? /** @type {string} */ (stringSuffix.string) : "");
 					const newRange = /** @type {Range} */ ([
 						/** @type {Range} */ (argExpr.range)[0],
 						/** @type {Range} */ ((stringSuffix || argExpr).range)[1]
@@ -1697,7 +1806,10 @@ class JavascriptParser extends Parser {
 					const prefix = param.isString() ? param : param.prefix;
 					const inner =
 						param.isWrapped() && param.wrappedInnerExpressions
-							? param.wrappedInnerExpressions.concat(innerExpressions.reverse())
+							? [
+									...param.wrappedInnerExpressions,
+									...innerExpressions.reverse()
+								]
 							: innerExpressions.reverse();
 					return new BasicEvaluatedExpression()
 						.setWrapped(prefix, stringSuffix, inner)
@@ -1705,7 +1817,7 @@ class JavascriptParser extends Parser {
 				} else if (param.isWrapped()) {
 					const postfix = stringSuffix || param.postfix;
 					const inner = param.wrappedInnerExpressions
-						? param.wrappedInnerExpressions.concat(innerExpressions.reverse())
+						? [...param.wrappedInnerExpressions, ...innerExpressions.reverse()]
 						: innerExpressions.reverse();
 					return new BasicEvaluatedExpression()
 						.setWrapped(param.prefix, postfix, inner)
@@ -1724,7 +1836,7 @@ class JavascriptParser extends Parser {
 			});
 		this.hooks.evaluateCallExpressionMember
 			.for("split")
-			.tap("JavascriptParser", (expr, param) => {
+			.tap(CLASS_NAME, (expr, param) => {
 				if (!param.isString()) return;
 				if (expr.arguments.length !== 1) return;
 				if (expr.arguments[0].type === "SpreadElement") return;
@@ -1748,7 +1860,7 @@ class JavascriptParser extends Parser {
 			});
 		this.hooks.evaluate
 			.for("ConditionalExpression")
-			.tap("JavascriptParser", _expr => {
+			.tap(CLASS_NAME, (_expr) => {
 				const expr = /** @type {ConditionalExpression} */ (_expr);
 
 				const condition = this.evaluateExpression(expr.test);
@@ -1781,71 +1893,67 @@ class JavascriptParser extends Parser {
 				res.setRange(/** @type {Range} */ (expr.range));
 				return res;
 			});
-		this.hooks.evaluate
-			.for("ArrayExpression")
-			.tap("JavascriptParser", _expr => {
-				const expr = /** @type {ArrayExpression} */ (_expr);
-
-				const items = expr.elements.map(
-					element =>
-						element !== null &&
-						element.type !== "SpreadElement" &&
-						this.evaluateExpression(element)
-				);
-				if (!items.every(Boolean)) return;
-				return new BasicEvaluatedExpression()
-					.setItems(/** @type {BasicEvaluatedExpression[]} */ (items))
-					.setRange(/** @type {Range} */ (expr.range));
-			});
-		this.hooks.evaluate
-			.for("ChainExpression")
-			.tap("JavascriptParser", _expr => {
-				const expr = /** @type {ChainExpression} */ (_expr);
-				/** @type {Expression[]} */
-				const optionalExpressionsStack = [];
-				/** @type {Expression|Super} */
-				let next = expr.expression;
-
-				while (
-					next.type === "MemberExpression" ||
-					next.type === "CallExpression"
-				) {
-					if (next.type === "MemberExpression") {
-						if (next.optional) {
-							// SuperNode can not be optional
-							optionalExpressionsStack.push(
-								/** @type {Expression} */ (next.object)
-							);
-						}
-						next = next.object;
-					} else {
-						if (next.optional) {
-							// SuperNode can not be optional
-							optionalExpressionsStack.push(
-								/** @type {Expression} */ (next.callee)
-							);
-						}
-						next = next.callee;
+		this.hooks.evaluate.for("ArrayExpression").tap(CLASS_NAME, (_expr) => {
+			const expr = /** @type {ArrayExpression} */ (_expr);
+
+			const items = expr.elements.map(
+				(element) =>
+					element !== null &&
+					element.type !== "SpreadElement" &&
+					this.evaluateExpression(element)
+			);
+			if (!items.every(Boolean)) return;
+			return new BasicEvaluatedExpression()
+				.setItems(/** @type {BasicEvaluatedExpression[]} */ (items))
+				.setRange(/** @type {Range} */ (expr.range));
+		});
+		this.hooks.evaluate.for("ChainExpression").tap(CLASS_NAME, (_expr) => {
+			const expr = /** @type {ChainExpression} */ (_expr);
+			/** @type {Expression[]} */
+			const optionalExpressionsStack = [];
+			/** @type {Expression | Super} */
+			let next = expr.expression;
+
+			while (
+				next.type === "MemberExpression" ||
+				next.type === "CallExpression"
+			) {
+				if (next.type === "MemberExpression") {
+					if (next.optional) {
+						// SuperNode can not be optional
+						optionalExpressionsStack.push(
+							/** @type {Expression} */ (next.object)
+						);
+					}
+					next = next.object;
+				} else {
+					if (next.optional) {
+						// SuperNode can not be optional
+						optionalExpressionsStack.push(
+							/** @type {Expression} */ (next.callee)
+						);
 					}
+					next = next.callee;
 				}
+			}
 
-				while (optionalExpressionsStack.length > 0) {
-					const expression =
-						/** @type {Expression} */
-						(optionalExpressionsStack.pop());
-					const evaluated = this.evaluateExpression(expression);
+			while (optionalExpressionsStack.length > 0) {
+				const expression =
+					/** @type {Expression} */
+					(optionalExpressionsStack.pop());
+				const evaluated = this.evaluateExpression(expression);
 
-					if (evaluated.asNullish()) {
-						return evaluated.setRange(/** @type {Range} */ (_expr.range));
-					}
+				if (evaluated.asNullish()) {
+					return evaluated.setRange(/** @type {Range} */ (_expr.range));
 				}
-				return this.evaluateExpression(expr.expression);
-			});
+			}
+			return this.evaluateExpression(expr.expression);
+		});
 	}
 
 	/**
 	 * @param {Expression} node node
-	 * @returns {Set<DestructuringAssignmentProperty> | undefined} destructured identifiers
+	 * @returns {DestructuringAssignmentProperties | undefined} destructured identifiers
 	 */
 	destructuringAssignmentPropertiesFor(node) {
 		if (!this.destructuringAssignmentProperties) return;
@@ -1854,7 +1962,7 @@ class JavascriptParser extends Parser {
 
 	/**
 	 * @param {Expression | SpreadElement} expr expression
-	 * @returns {string | VariableInfoInterface | undefined} identifier
+	 * @returns {string | VariableInfo | undefined} identifier
 	 */
 	getRenameIdentifier(expr) {
 		const result = this.evaluateExpression(expr);
@@ -1864,7 +1972,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
-	 * @param {ClassExpression | ClassDeclaration} classy a class node
+	 * @param {ClassExpression | ClassDeclaration | MaybeNamedClassDeclaration} classy a class node
 	 * @returns {void}
 	 */
 	walkClass(classy) {
@@ -1881,13 +1989,20 @@ class JavascriptParser extends Parser {
 				scopeParams.push(classy.id);
 			}
 			this.inClassScope(true, scopeParams, () => {
-				for (const classElement of /** @type {TODO} */ (classy.body.body)) {
+				for (const classElement of classy.body.body) {
 					if (!this.hooks.classBodyElement.call(classElement, classy)) {
-						if (classElement.computed && classElement.key) {
-							this.walkExpression(classElement.key);
-						}
-						if (classElement.value) {
+						if (classElement.type === "StaticBlock") {
+							const wasTopLevel = this.scope.topLevelScope;
+							this.scope.topLevelScope = false;
+							this.walkBlockStatement(classElement);
+							this.scope.topLevelScope = wasTopLevel;
+						} else {
+							if (classElement.computed && classElement.key) {
+								this.walkExpression(classElement.key);
+							}
+
 							if (
+								classElement.value &&
 								!this.hooks.classBodyValue.call(
 									classElement.value,
 									classElement,
@@ -1899,11 +2014,6 @@ class JavascriptParser extends Parser {
 								this.walkExpression(classElement.value);
 								this.scope.topLevelScope = wasTopLevel;
 							}
-						} else if (classElement.type === "StaticBlock") {
-							const wasTopLevel = this.scope.topLevelScope;
-							this.scope.topLevelScope = false;
-							this.walkBlockStatement(classElement);
-							this.scope.topLevelScope = wasTopLevel;
 						}
 					}
 				}
@@ -1911,6 +2021,32 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * Module pre walking iterates the scope for import entries
+	 * @param {(Statement | ModuleDeclaration)[]} statements statements
+	 */
+	modulePreWalkStatements(statements) {
+		for (let index = 0, len = statements.length; index < len; index++) {
+			const statement = statements[index];
+			/** @type {StatementPath} */
+			(this.statementPath).push(statement);
+			switch (statement.type) {
+				case "ImportDeclaration":
+					this.modulePreWalkImportDeclaration(statement);
+					break;
+				case "ExportAllDeclaration":
+					this.modulePreWalkExportAllDeclaration(statement);
+					break;
+				case "ExportNamedDeclaration":
+					this.modulePreWalkExportNamedDeclaration(statement);
+					break;
+			}
+			this.prevStatement =
+				/** @type {StatementPath} */
+				(this.statementPath).pop();
+		}
+	}
+
 	/**
 	 * Pre walking iterates the scope for variable declarations
 	 * @param {(Statement | ModuleDeclaration)[]} statements statements
@@ -1938,15 +2074,30 @@ class JavascriptParser extends Parser {
 	 * @param {(Statement | ModuleDeclaration)[]} statements statements
 	 */
 	walkStatements(statements) {
+		let onlyFunctionDeclaration = false;
+
 		for (let index = 0, len = statements.length; index < len; index++) {
 			const statement = statements[index];
+
+			if (
+				onlyFunctionDeclaration &&
+				statement.type !== "FunctionDeclaration" &&
+				this.hooks.unusedStatement.call(/** @type {Statement} */ (statement))
+			) {
+				continue;
+			}
+
 			this.walkStatement(statement);
+
+			if (this.scope.terminated) {
+				onlyFunctionDeclaration = true;
+			}
 		}
 	}
 
 	/**
 	 * Walking iterates the statements and expressions and processes them
-	 * @param {Statement | ModuleDeclaration} statement statement
+	 * @param {Statement | ModuleDeclaration | MaybeNamedClassDeclaration | MaybeNamedFunctionDeclaration} statement statement
 	 */
 	preWalkStatement(statement) {
 		/** @type {StatementPath} */
@@ -2004,7 +2155,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
-	 * @param {Statement | ModuleDeclaration} statement statement
+	 * @param {Statement | ModuleDeclaration | MaybeNamedClassDeclaration | MaybeNamedFunctionDeclaration} statement statement
 	 */
 	blockPreWalkStatement(statement) {
 		/** @type {StatementPath} */
@@ -2016,12 +2167,6 @@ class JavascriptParser extends Parser {
 			return;
 		}
 		switch (statement.type) {
-			case "ImportDeclaration":
-				this.blockPreWalkImportDeclaration(statement);
-				break;
-			case "ExportAllDeclaration":
-				this.blockPreWalkExportAllDeclaration(statement);
-				break;
 			case "ExportDefaultDeclaration":
 				this.blockPreWalkExportDefaultDeclaration(statement);
 				break;
@@ -2043,7 +2188,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
-	 * @param {Statement | ModuleDeclaration} statement statement
+	 * @param {Statement | ModuleDeclaration | MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration} statement statement
 	 */
 	walkStatement(statement) {
 		/** @type {StatementPath} */
@@ -2138,7 +2283,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
-	 * @param {BlockStatement} statement block statement
+	 * @param {BlockStatement | StaticBlock} statement block statement
 	 */
 	walkBlockStatement(statement) {
 		this.inBlockScope(() => {
@@ -2147,7 +2292,7 @@ class JavascriptParser extends Parser {
 			this.blockPreWalkStatements(body);
 			this.prevStatement = prev;
 			this.walkStatements(body);
-		});
+		}, true);
 	}
 
 	/**
@@ -2175,9 +2320,20 @@ class JavascriptParser extends Parser {
 		if (result === undefined) {
 			this.walkExpression(statement.test);
 			this.walkNestedStatement(statement.consequent);
+
+			const consequentTerminated = this.scope.terminated;
+			this.scope.terminated = undefined;
+
 			if (statement.alternate) {
 				this.walkNestedStatement(statement.alternate);
 			}
+
+			const alternateTerminated = this.scope.terminated;
+
+			this.scope.terminated =
+				consequentTerminated && alternateTerminated
+					? alternateTerminated
+					: undefined;
 		} else if (result) {
 			this.walkNestedStatement(statement.consequent);
 		} else if (statement.alternate) {
@@ -2201,7 +2357,9 @@ class JavascriptParser extends Parser {
 			const result = hook.call(statement);
 			if (result === true) return;
 		}
-		this.walkNestedStatement(statement.body);
+		this.inBlockScope(() => {
+			this.walkNestedStatement(statement.body);
+		});
 	}
 
 	/**
@@ -2215,8 +2373,10 @@ class JavascriptParser extends Parser {
 	 * @param {WithStatement} statement with statement
 	 */
 	walkWithStatement(statement) {
-		this.walkExpression(statement.object);
-		this.walkNestedStatement(statement.body);
+		this.inBlockScope(() => {
+			this.walkExpression(statement.object);
+			this.walkNestedStatement(statement.body);
+		});
 	}
 
 	/**
@@ -2239,6 +2399,14 @@ class JavascriptParser extends Parser {
 	 */
 	walkTerminatingStatement(statement) {
 		if (statement.argument) this.walkExpression(statement.argument);
+		// Skip top level scope because to handle `export` and `module.exports` after terminate
+		if (this.scope.topLevelScope === true) return;
+		if (this.hooks.terminate.call(statement)) {
+			this.scope.terminated =
+				statement.type === "ReturnStatement"
+					? SCOPE_INFO_TERMINATED_RETURN
+					: SCOPE_INFO_TERMINATED_THROW;
+		}
 	}
 
 	/**
@@ -2275,8 +2443,30 @@ class JavascriptParser extends Parser {
 			this.walkStatement(statement.block);
 			this.scope.inTry = false;
 		}
+
+		const tryTerminated = this.scope.terminated;
+		this.scope.terminated = undefined;
+
 		if (statement.handler) this.walkCatchClause(statement.handler);
-		if (statement.finalizer) this.walkStatement(statement.finalizer);
+
+		const handlerTerminated = this.scope.terminated;
+		this.scope.terminated = undefined;
+
+		if (statement.finalizer) {
+			this.walkStatement(statement.finalizer);
+		}
+
+		const finalizerTerminated = this.scope.terminated;
+		this.scope.terminated = undefined;
+
+		if (finalizerTerminated) {
+			this.scope.terminated = finalizerTerminated;
+		} else if (
+			tryTerminated &&
+			(statement.handler ? handlerTerminated : true)
+		) {
+			this.scope.terminated = handlerTerminated || tryTerminated;
+		}
 	}
 
 	/**
@@ -2290,8 +2480,10 @@ class JavascriptParser extends Parser {
 	 * @param {WhileStatement} statement while statement
 	 */
 	walkWhileStatement(statement) {
-		this.walkExpression(statement.test);
-		this.walkNestedStatement(statement.body);
+		this.inBlockScope(() => {
+			this.walkExpression(statement.test);
+			this.walkNestedStatement(statement.body);
+		});
 	}
 
 	/**
@@ -2305,8 +2497,10 @@ class JavascriptParser extends Parser {
 	 * @param {DoWhileStatement} statement do while statement
 	 */
 	walkDoWhileStatement(statement) {
-		this.walkNestedStatement(statement.body);
-		this.walkExpression(statement.test);
+		this.inBlockScope(() => {
+			this.walkNestedStatement(statement.body);
+			this.walkExpression(statement.test);
+		});
 	}
 
 	/**
@@ -2339,7 +2533,9 @@ class JavascriptParser extends Parser {
 			if (statement.update) {
 				this.walkExpression(statement.update);
 			}
+
 			const body = statement.body;
+
 			if (body.type === "BlockStatement") {
 				// no need to add additional scope
 				const prev = this.prevStatement;
@@ -2373,8 +2569,11 @@ class JavascriptParser extends Parser {
 			} else {
 				this.walkPattern(statement.left);
 			}
+
 			this.walkExpression(statement.right);
+
 			const body = statement.body;
+
 			if (body.type === "BlockStatement") {
 				// no need to add additional scope
 				const prev = this.prevStatement;
@@ -2411,8 +2610,11 @@ class JavascriptParser extends Parser {
 			} else {
 				this.walkPattern(statement.left);
 			}
+
 			this.walkExpression(statement.right);
+
 			const body = statement.body;
+
 			if (body.type === "BlockStatement") {
 				// no need to add additional scope
 				const prev = this.prevStatement;
@@ -2426,7 +2628,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
-	 * @param {FunctionDeclaration} statement function declaration
+	 * @param {FunctionDeclaration | MaybeNamedFunctionDeclaration} statement function declaration
 	 */
 	preWalkFunctionDeclaration(statement) {
 		if (statement.id) {
@@ -2435,7 +2637,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
-	 * @param {FunctionDeclaration} statement function declaration
+	 * @param {FunctionDeclaration | MaybeNamedFunctionDeclaration} statement function declaration
 	 */
 	walkFunctionDeclaration(statement) {
 		const wasTopLevel = this.scope.topLevelScope;
@@ -2444,15 +2646,14 @@ class JavascriptParser extends Parser {
 			for (const param of statement.params) {
 				this.walkPattern(param);
 			}
-			if (statement.body.type === "BlockStatement") {
-				this.detectMode(statement.body.body);
-				const prev = this.prevStatement;
-				this.preWalkStatement(statement.body);
-				this.prevStatement = prev;
-				this.walkStatement(statement.body);
-			} else {
-				this.walkExpression(statement.body);
-			}
+
+			this.detectMode(statement.body.body);
+
+			const prev = this.prevStatement;
+
+			this.preWalkStatement(statement.body);
+			this.prevStatement = prev;
+			this.walkStatement(statement.body);
 		});
 		this.scope.topLevelScope = wasTopLevel;
 	}
@@ -2472,39 +2673,54 @@ class JavascriptParser extends Parser {
 	 * @param {AssignmentExpression} expression assignment expression
 	 */
 	preWalkAssignmentExpression(expression) {
+		this.enterDestructuringAssignment(expression.left, expression.right);
+	}
+
+	/**
+	 * @param {Pattern} pattern pattern
+	 * @param {Expression} expression assignment expression
+	 * @returns {Expression | undefined} destructuring expression
+	 */
+	enterDestructuringAssignment(pattern, expression) {
 		if (
-			expression.left.type !== "ObjectPattern" ||
+			pattern.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);
+		const expr =
+			expression.type === "AwaitExpression" ? expression.argument : expression;
+
+		const destructuring =
+			expr.type === "AssignmentExpression"
+				? this.enterDestructuringAssignment(expr.left, expr.right)
+				: this.hooks.collectDestructuringAssignmentProperties.call(expr)
+					? expr
+					: undefined;
+
+		if (destructuring) {
+			const keys = this._preWalkObjectPattern(pattern);
+			if (!keys) return;
+
+			// check multiple assignments
+			if (this.destructuringAssignmentProperties.has(destructuring)) {
+				const set =
+					/** @type {DestructuringAssignmentProperties} */
+					(this.destructuringAssignmentProperties.get(destructuring));
+				for (const id of keys) set.add(id);
+			} else {
+				this.destructuringAssignmentProperties.set(destructuring, keys);
+			}
 		}
+
+		return destructuring;
 	}
 
 	/**
 	 * @param {ImportDeclaration} statement statement
 	 */
-	blockPreWalkImportDeclaration(statement) {
+	modulePreWalkImportDeclaration(statement) {
 		const source = /** @type {ImportSource} */ (statement.source.value);
 		this.hooks.import.call(statement, source);
 		for (const specifier of statement.specifiers) {
@@ -2574,14 +2790,49 @@ class JavascriptParser extends Parser {
 	/**
 	 * @param {ExportNamedDeclaration} statement statement
 	 */
-	blockPreWalkExportNamedDeclaration(statement) {
-		let source;
-		if (statement.source) {
-			source = /** @type {ImportSource} */ (statement.source.value);
-			this.hooks.exportImport.call(statement, source);
-		} else {
-			this.hooks.export.call(statement);
+	modulePreWalkExportNamedDeclaration(statement) {
+		if (!statement.source) return;
+		const source = /** @type {ImportSource} */ (statement.source.value);
+		this.hooks.exportImport.call(statement, source);
+		if (statement.specifiers) {
+			for (
+				let specifierIndex = 0;
+				specifierIndex < statement.specifiers.length;
+				specifierIndex++
+			) {
+				const specifier = statement.specifiers[specifierIndex];
+				switch (specifier.type) {
+					case "ExportSpecifier": {
+						const localName =
+							/** @type {Identifier} */ (specifier.local).name ||
+							/** @type {string} */ (
+								/** @type {Literal} */ (specifier.local).value
+							);
+						const name =
+							/** @type {Identifier} */
+							(specifier.exported).name ||
+							/** @type {string} */
+							(/** @type {Literal} */ (specifier.exported).value);
+						this.hooks.exportImportSpecifier.call(
+							statement,
+							source,
+							localName,
+							name,
+							specifierIndex
+						);
+						break;
+					}
+				}
+			}
 		}
+	}
+
+	/**
+	 * @param {ExportNamedDeclaration} statement statement
+	 */
+	blockPreWalkExportNamedDeclaration(statement) {
+		if (statement.source) return;
+		this.hooks.export.call(statement);
 		if (
 			statement.declaration &&
 			!this.hooks.exportDeclaration.call(statement, statement.declaration)
@@ -2591,7 +2842,7 @@ class JavascriptParser extends Parser {
 			this.prevStatement = prev;
 			this.blockPreWalkStatement(statement.declaration);
 			let index = 0;
-			this.enterDeclaration(statement.declaration, def => {
+			this.enterDeclaration(statement.declaration, (def) => {
 				this.hooks.exportSpecifier.call(statement, def, def, index++);
 			});
 		}
@@ -2614,22 +2865,12 @@ class JavascriptParser extends Parser {
 							(specifier.exported).name ||
 							/** @type {string} */
 							(/** @type {Literal} */ (specifier.exported).value);
-						if (source) {
-							this.hooks.exportImportSpecifier.call(
-								statement,
-								source,
-								localName,
-								name,
-								specifierIndex
-							);
-						} else {
-							this.hooks.exportSpecifier.call(
-								statement,
-								localName,
-								name,
-								specifierIndex
-							);
-						}
+						this.hooks.exportSpecifier.call(
+							statement,
+							localName,
+							name,
+							specifierIndex
+						);
 						break;
 					}
 				}
@@ -2647,26 +2888,34 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
-	 * @param {TODO} statement statement
+	 * @param {ExportDefaultDeclaration} statement statement
 	 */
 	blockPreWalkExportDefaultDeclaration(statement) {
-		const prev = this.prevStatement;
-		this.preWalkStatement(statement.declaration);
-		this.prevStatement = prev;
-		this.blockPreWalkStatement(statement.declaration);
 		if (
-			/** @type {FunctionDeclaration | ClassDeclaration} */ (
-				statement.declaration
-			).id &&
+			statement.declaration.type === "FunctionDeclaration" ||
+			statement.declaration.type === "ClassDeclaration"
+		) {
+			const prev = this.prevStatement;
+
+			this.preWalkStatement(statement.declaration);
+			this.prevStatement = prev;
+			this.blockPreWalkStatement(statement.declaration);
+		}
+
+		if (
+			/** @type {MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration} */
+			(statement.declaration).id &&
 			statement.declaration.type !== "FunctionExpression" &&
 			statement.declaration.type !== "ClassExpression"
 		) {
 			const declaration =
-				/** @type {FunctionDeclaration | ClassDeclaration} */
+				/** @type {MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration} */
 				(statement.declaration);
+
 			this.hooks.exportSpecifier.call(
 				statement,
-				declaration.id.name,
+				/** @type {Identifier} */
+				(declaration.id).name,
 				"default",
 				undefined
 			);
@@ -2679,9 +2928,8 @@ class JavascriptParser extends Parser {
 	walkExportDefaultDeclaration(statement) {
 		this.hooks.export.call(statement);
 		if (
-			/** @type {FunctionDeclaration | ClassDeclaration} */ (
-				statement.declaration
-			).id &&
+			/** @type {FunctionDeclaration | ClassDeclaration} */
+			(statement.declaration).id &&
 			statement.declaration.type !== "FunctionExpression" &&
 			statement.declaration.type !== "ClassExpression"
 		) {
@@ -2699,34 +2947,19 @@ class JavascriptParser extends Parser {
 				statement.declaration.type === "FunctionDeclaration" ||
 				statement.declaration.type === "ClassDeclaration"
 			) {
-				this.walkStatement(
-					/** @type {FunctionDeclaration | ClassDeclaration} */
-					(statement.declaration)
-				);
+				this.walkStatement(statement.declaration);
 			} else {
 				this.walkExpression(statement.declaration);
 			}
 
-			if (
-				!this.hooks.exportExpression.call(
-					statement,
-					/** @type {TODO} */ (statement).declaration
-				)
-			) {
-				this.hooks.exportSpecifier.call(
-					statement,
-					/** @type {TODO} */ (statement.declaration),
-					"default",
-					undefined
-				);
-			}
+			this.hooks.exportExpression.call(statement, statement.declaration);
 		}
 	}
 
 	/**
 	 * @param {ExportAllDeclaration} statement statement
 	 */
-	blockPreWalkExportAllDeclaration(statement) {
+	modulePreWalkExportAllDeclaration(statement) {
 		const source = /** @type {ImportSource} */ (statement.source.value);
 		const name = statement.exported
 			? /** @type {Identifier} */
@@ -2751,16 +2984,19 @@ class JavascriptParser extends Parser {
 	 */
 	blockPreWalkVariableDeclaration(statement) {
 		if (statement.kind === "var") return;
+
 		const hookMap =
 			statement.kind === "const"
 				? this.hooks.varDeclarationConst
-				: this.hooks.varDeclarationLet;
+				: statement.kind === "using" || statement.kind === "await using"
+					? this.hooks.varDeclarationUsing
+					: this.hooks.varDeclarationLet;
 		this._preWalkVariableDeclaration(statement, hookMap);
 	}
 
 	/**
 	 * @param {VariableDeclaration} statement variable declaration
-	 * @param {TODO} hookMap map of hooks
+	 * @param {HookMap<SyncBailHook<[Identifier], boolean | void>>} hookMap map of hooks
 	 */
 	_preWalkVariableDeclaration(statement, hookMap) {
 		for (const declarator of statement.declarations) {
@@ -2768,11 +3004,11 @@ class JavascriptParser extends Parser {
 				case "VariableDeclarator": {
 					this.preWalkVariableDeclarator(declarator);
 					if (!this.hooks.preDeclarator.call(declarator, statement)) {
-						this.enterPattern(declarator.id, (name, decl) => {
+						this.enterPattern(declarator.id, (name, ident) => {
 							let hook = hookMap.get(name);
-							if (hook === undefined || !hook.call(decl)) {
+							if (hook === undefined || !hook.call(ident)) {
 								hook = this.hooks.varDeclaration.get(name);
-								if (hook === undefined || !hook.call(decl)) {
+								if (hook === undefined || !hook.call(ident)) {
 									this.defineVariable(name);
 								}
 							}
@@ -2786,32 +3022,55 @@ class JavascriptParser extends Parser {
 
 	/**
 	 * @param {ObjectPattern} objectPattern object pattern
-	 * @returns {Set<DestructuringAssignmentProperty> | undefined} set of names or undefined if not all keys are identifiers
+	 * @returns {DestructuringAssignmentProperties | undefined} set of names or undefined if not all keys are identifiers
 	 */
 	_preWalkObjectPattern(objectPattern) {
-		/** @type {Set<DestructuringAssignmentProperty>} */
+		/** @type {DestructuringAssignmentProperties} */
 		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;
+			if (property.shorthand) {
+				if (property.value.type === "Identifier") {
+					this.scope.inShorthand = property.value.name;
+				} else if (
+					property.value.type === "AssignmentPattern" &&
+					property.value.left.type === "Identifier"
+				) {
+					this.scope.inShorthand = property.value.left.name;
+				}
 			}
 			const key = property.key;
-			if (key.type === "Identifier") {
+			if (key.type === "Identifier" && !property.computed) {
+				const pattern =
+					property.value.type === "ObjectPattern"
+						? this._preWalkObjectPattern(property.value)
+						: property.value.type === "ArrayPattern"
+							? this._preWalkArrayPattern(property.value)
+							: undefined;
 				props.add({
 					id: key.name,
-					range: key.range,
+					range: /** @type {Range} */ (key.range),
+					loc: /** @type {SourceLocation} */ (key.loc),
+					pattern,
 					shorthand: this.scope.inShorthand
 				});
 			} else {
 				const id = this.evaluateExpression(key);
 				const str = id.asString();
 				if (str) {
+					const pattern =
+						property.value.type === "ObjectPattern"
+							? this._preWalkObjectPattern(property.value)
+							: property.value.type === "ArrayPattern"
+								? this._preWalkArrayPattern(property.value)
+								: undefined;
 					props.add({
 						id: str,
-						range: key.range,
+						range: /** @type {Range} */ (key.range),
+						loc: /** @type {SourceLocation} */ (key.loc),
+						pattern,
 						shorthand: this.scope.inShorthand
 					});
 				} else {
@@ -2825,28 +3084,42 @@ class JavascriptParser extends Parser {
 		return props;
 	}
 
+	/**
+	 * @param {ArrayPattern} arrayPattern array pattern
+	 * @returns {Set<DestructuringAssignmentProperty> | undefined} set of names or undefined if not all keys are identifiers
+	 */
+	_preWalkArrayPattern(arrayPattern) {
+		/** @type {Set<DestructuringAssignmentProperty>} */
+		const props = new Set();
+		const elements = arrayPattern.elements;
+		for (let i = 0; i < elements.length; i++) {
+			const element = elements[i];
+			if (!element) continue;
+			if (element.type === "RestElement") return;
+			const pattern =
+				element.type === "ObjectPattern"
+					? this._preWalkObjectPattern(element)
+					: element.type === "ArrayPattern"
+						? this._preWalkArrayPattern(element)
+						: undefined;
+			props.add({
+				id: `${i}`,
+				range: /** @type {Range} */ (element.range),
+				loc: /** @type {SourceLocation} */ (element.loc),
+				pattern,
+				shorthand: 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);
+		if (declarator.init) {
+			this.enterDestructuringAssignment(declarator.id, declarator.init);
 		}
 	}
 
@@ -2887,7 +3160,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
-	 * @param {ClassDeclaration} statement class declaration
+	 * @param {ClassDeclaration | MaybeNamedClassDeclaration} statement class declaration
 	 */
 	blockPreWalkClassDeclaration(statement) {
 		if (statement.id) {
@@ -2896,7 +3169,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
-	 * @param {ClassDeclaration} statement class declaration
+	 * @param {ClassDeclaration | MaybeNamedClassDeclaration} statement class declaration
 	 */
 	walkClassDeclaration(statement) {
 		this.walkClass(statement);
@@ -2943,8 +3216,10 @@ class JavascriptParser extends Parser {
 				if (switchCase.test) {
 					this.walkExpression(switchCase.test);
 				}
+
 				if (switchCase.consequent.length > 0) {
 					this.walkStatements(switchCase.consequent);
+					this.scope.terminated = undefined;
 				}
 			}
 		});
@@ -2964,7 +3239,7 @@ class JavascriptParser extends Parser {
 		this.inBlockScope(() => {
 			// Error binding is optional in catch clause since ECMAScript 2019
 			if (catchClause.param !== null) {
-				this.enterPattern(catchClause.param, ident => {
+				this.enterPattern(catchClause.param, (ident) => {
 					this.defineVariable(ident);
 				});
 				this.walkPattern(catchClause.param);
@@ -2973,7 +3248,7 @@ class JavascriptParser extends Parser {
 			this.blockPreWalkStatement(catchClause.body);
 			this.prevStatement = prev;
 			this.walkStatement(catchClause.body);
-		});
+		}, true);
 	}
 
 	/**
@@ -3052,7 +3327,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
-	 * @param {TODO} expression expression
+	 * @param {Expression | SpreadElement | PrivateIdentifier | Super} expression expression
 	 */
 	walkExpression(expression) {
 		switch (expression.type) {
@@ -3138,8 +3413,9 @@ class JavascriptParser extends Parser {
 	 * @param {AwaitExpression} expression await expression
 	 */
 	walkAwaitExpression(expression) {
-		if (this.scope.topLevelScope === true)
+		if (this.scope.topLevelScope === true) {
 			this.hooks.topLevelAwait.call(expression);
+		}
 		this.walkExpression(expression.argument);
 	}
 
@@ -3191,7 +3467,10 @@ class JavascriptParser extends Parser {
 			this.walkIdentifier(prop.value);
 			this.scope.inShorthand = false;
 		} else {
-			this.walkExpression(prop.value);
+			this.walkExpression(
+				/** @type {Exclude<Property["value"], AssignmentPattern | ObjectPattern | ArrayPattern | RestElement>} */
+				(prop.value)
+			);
 		}
 	}
 
@@ -3212,15 +3491,14 @@ class JavascriptParser extends Parser {
 			for (const param of expression.params) {
 				this.walkPattern(param);
 			}
-			if (expression.body.type === "BlockStatement") {
-				this.detectMode(expression.body.body);
-				const prev = this.prevStatement;
-				this.preWalkStatement(expression.body);
-				this.prevStatement = prev;
-				this.walkStatement(expression.body);
-			} else {
-				this.walkExpression(expression.body);
-			}
+
+			this.detectMode(expression.body.body);
+
+			const prev = this.prevStatement;
+
+			this.preWalkStatement(expression.body);
+			this.prevStatement = prev;
+			this.walkStatement(expression.body);
 		});
 		this.scope.topLevelScope = wasTopLevel;
 	}
@@ -3377,16 +3655,17 @@ class JavascriptParser extends Parser {
 				return;
 			}
 			this.walkExpression(expression.right);
-			this.enterPattern(expression.left, (name, decl) => {
+			this.enterPattern(expression.left, (name, _decl) => {
 				if (!this.callHooksForName(this.hooks.assign, name, expression)) {
-					this.walkExpression(expression.left);
+					this.walkExpression(
+						/** @type {MemberExpression} */
+						(expression.left)
+					);
 				}
 			});
-			return;
-		}
-		if (expression.left.type.endsWith("Pattern")) {
+		} else if (expression.left.type.endsWith("Pattern")) {
 			this.walkExpression(expression.right);
-			this.enterPattern(expression.left, (name, decl) => {
+			this.enterPattern(expression.left, (name, _decl) => {
 				if (!this.callHooksForName(this.hooks.assign, name, expression)) {
 					this.defineVariable(name);
 				}
@@ -3412,7 +3691,10 @@ class JavascriptParser extends Parser {
 			this.walkExpression(expression.left);
 		} else {
 			this.walkExpression(expression.right);
-			this.walkExpression(expression.left);
+			this.walkExpression(
+				/** @type {Exclude<AssignmentExpression["left"], Identifier | RestElement | MemberExpression | ObjectPattern | ArrayPattern | AssignmentPattern>} */
+				(expression.left)
+			);
 		}
 	}
 
@@ -3424,6 +3706,7 @@ class JavascriptParser extends Parser {
 		if (result === undefined) {
 			this.walkExpression(expression.test);
 			this.walkExpression(expression.consequent);
+
 			if (expression.alternate) {
 				this.walkExpression(expression.alternate);
 			}
@@ -3513,9 +3796,9 @@ class JavascriptParser extends Parser {
 	_walkIIFE(functionExpression, options, currentThis) {
 		/**
 		 * @param {Expression | SpreadElement} argOrThis arg or this
-		 * @returns {string | VariableInfoInterface | undefined} var info
+		 * @returns {string | VariableInfo | undefined} var info
 		 */
-		const getVarInfo = argOrThis => {
+		const getVarInfo = (argOrThis) => {
 			const renameIdentifier = this.getRenameIdentifier(argOrThis);
 			if (
 				renameIdentifier &&
@@ -3597,19 +3880,19 @@ class JavascriptParser extends Parser {
 		 * @param {FunctionExpression | ArrowFunctionExpression} fn function
 		 * @returns {boolean} true when simple function
 		 */
-		const isSimpleFunction = fn =>
-			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") &&
+			/** @type {boolean} */
+			(
+				/** @type {Identifier} */
+				(expression.callee.property).name === "call" ||
+					/** @type {Identifier} */
+					(expression.callee.property).name === "bind"
+			) &&
 			expression.arguments.length > 0 &&
 			isSimpleFunction(
 				/** @type {FunctionExpression | ArrowFunctionExpression} */
@@ -3655,10 +3938,20 @@ class JavascriptParser extends Parser {
 					);
 					if (result === true) return;
 				}
+				// import("./m").then(m => { ... })
+				if (
+					expression.callee.object.type === "ImportExpression" &&
+					expression.callee.property.type === "Identifier" &&
+					expression.callee.property.name === "then"
+				) {
+					const result = this.hooks.importCall.call(
+						expression.callee.object,
+						expression
+					);
+					if (result === true) return;
+				}
 			}
-			const callee = this.evaluateExpression(
-				/** @type {TODO} */ (expression.callee)
-			);
+			const callee = this.evaluateExpression(expression.callee);
 			if (callee.isIdentifier()) {
 				const result1 = this.callHooksForInfo(
 					this.hooks.callMemberChain,
@@ -3687,8 +3980,9 @@ class JavascriptParser extends Parser {
 				if (expression.callee.type === "MemberExpression") {
 					// because of call context we need to walk the call context as expression
 					this.walkExpression(expression.callee.object);
-					if (expression.callee.computed === true)
+					if (expression.callee.computed === true) {
 						this.walkExpression(expression.callee.property);
+					}
 				} else {
 					this.walkExpression(expression.callee);
 				}
@@ -3730,7 +4024,7 @@ class JavascriptParser extends Parser {
 						expression,
 						exprInfo.name,
 						exprInfo.rootInfo,
-						members.slice(),
+						[...members],
 						() =>
 							this.callHooksForInfo(
 								this.hooks.unhandledExpressionMemberChain,
@@ -3764,11 +4058,12 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
-	 * @param {TODO} expression member expression
+	 * @template R
+	 * @param {MemberExpression} expression member expression
 	 * @param {string} name name
 	 * @param {string | VariableInfo} rootInfo root info
-	 * @param {string[]} members members
-	 * @param {TODO} onUnhandled on unhandled callback
+	 * @param {Members} members members
+	 * @param {() => R | undefined} onUnhandled on unhandled callback
 	 */
 	walkMemberExpressionWithExpressionName(
 		expression,
@@ -3781,7 +4076,9 @@ class JavascriptParser extends Parser {
 			// optimize the case where expression.object is a MemberExpression too.
 			// we can keep info here when calling walkMemberExpression directly
 			const property =
-				expression.property.name || `${expression.property.value}`;
+				/** @type {Identifier} */
+				(expression.property).name ||
+				`${/** @type {Literal} */ (expression.property).value}`;
 			name = name.slice(0, -property.length - 1);
 			members.pop();
 			const result = this.callHooksForInfo(
@@ -3847,8 +4144,8 @@ class JavascriptParser extends Parser {
 	 * @template R
 	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks the should be called
 	 * @param {Expression | Super} 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 {((name: string, rootInfo: string | ScopeInfo | VariableInfo, getMembers: () => Members) => R) | undefined} fallback callback when variable in not handled by hooks
+	 * @param {((result?: string) => R | undefined) | undefined} defined callback when variable is defined
 	 * @param {AsArray<T>} args args for the hook
 	 * @returns {R | undefined} result of hook
 	 */
@@ -3869,7 +4166,7 @@ class JavascriptParser extends Parser {
 				hookMap,
 				members.length === 0 ? exprName.rootInfo : exprName.name,
 				fallback &&
-					(name => fallback(name, exprName.rootInfo, exprName.getMembers)),
+					((name) => fallback(name, exprName.rootInfo, exprName.getMembers)),
 				defined && (() => defined(exprName.name)),
 				...args
 			);
@@ -3899,7 +4196,7 @@ class JavascriptParser extends Parser {
 	 * @template R
 	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks that should be called
 	 * @param {ExportedVariableInfo} info variable info
-	 * @param  {AsArray<T>} args args for the hook
+	 * @param {AsArray<T>} args args for the hook
 	 * @returns {R | undefined} result of hook
 	 */
 	callHooksForInfo(hookMap, info, ...args) {
@@ -3917,8 +4214,8 @@ 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) | undefined} fallback callback when variable in not handled by hooks
-	 * @param {(function(string=): any) | undefined} defined callback when variable is defined
+	 * @param {((name: string) => R | undefined) | undefined} fallback callback when variable in not handled by hooks
+	 * @param {((result?: string) => R | undefined) | undefined} defined callback when variable is defined
 	 * @param {AsArray<T>} args args for the hook
 	 * @returns {R | undefined} result of hook
 	 */
@@ -3944,13 +4241,13 @@ class JavascriptParser extends Parser {
 				}
 				tagInfo = tagInfo.next;
 			}
-			if (info.freeName === true) {
+			if (!info.isFree() && !info.isTagged()) {
 				if (defined !== undefined) {
 					return defined();
 				}
 				return;
 			}
-			name = info.freeName;
+			name = info.name;
 		}
 		const hook = hookMap.get(name);
 		if (hook !== undefined) {
@@ -3967,8 +4264,8 @@ 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) | undefined} fallback callback when variable in not handled by hooks
-	 * @param {(function(): any) | undefined} defined callback when variable is defined
+	 * @param {((value: string) => R | undefined) | undefined} fallback callback when variable in not handled by hooks
+	 * @param {(() => R) | undefined} defined callback when variable is defined
 	 * @param {AsArray<T>} args args for the hook
 	 * @returns {R | undefined} result of hook
 	 */
@@ -3984,8 +4281,8 @@ class JavascriptParser extends Parser {
 
 	/**
 	 * @deprecated
-	 * @param {any} params scope params
-	 * @param {function(): void} fn inner function
+	 * @param {(string | Pattern | Property)[]} params scope params
+	 * @param {() => void} fn inner function
 	 * @returns {void}
 	 */
 	inScope(params, fn) {
@@ -3997,12 +4294,13 @@ class JavascriptParser extends Parser {
 			inTaggedTemplateTag: false,
 			isStrict: oldScope.isStrict,
 			isAsmJs: oldScope.isAsmJs,
+			terminated: undefined,
 			definitions: oldScope.definitions.createChild()
 		};
 
 		this.undefineVariable("this");
 
-		this.enterPatterns(params, ident => {
+		this.enterPatterns(params, (ident) => {
 			this.defineVariable(ident);
 		});
 
@@ -4014,7 +4312,7 @@ class JavascriptParser extends Parser {
 	/**
 	 * @param {boolean} hasThis true, when this is defined
 	 * @param {Identifier[]} params scope params
-	 * @param {function(): void} fn inner function
+	 * @param {() => void} fn inner function
 	 * @returns {void}
 	 */
 	inClassScope(hasThis, params, fn) {
@@ -4026,6 +4324,7 @@ class JavascriptParser extends Parser {
 			inTaggedTemplateTag: false,
 			isStrict: oldScope.isStrict,
 			isAsmJs: oldScope.isAsmJs,
+			terminated: undefined,
 			definitions: oldScope.definitions.createChild()
 		};
 
@@ -4033,7 +4332,7 @@ class JavascriptParser extends Parser {
 			this.undefineVariable("this");
 		}
 
-		this.enterPatterns(params, ident => {
+		this.enterPatterns(params, (ident) => {
 			this.defineVariable(ident);
 		});
 
@@ -4045,7 +4344,7 @@ class JavascriptParser extends Parser {
 	/**
 	 * @param {boolean} hasThis true, when this is defined
 	 * @param {(Pattern | string)[]} params scope params
-	 * @param {function(): void} fn inner function
+	 * @param {() => void} fn inner function
 	 * @returns {void}
 	 */
 	inFunctionScope(hasThis, params, fn) {
@@ -4057,6 +4356,7 @@ class JavascriptParser extends Parser {
 			inTaggedTemplateTag: false,
 			isStrict: oldScope.isStrict,
 			isAsmJs: oldScope.isAsmJs,
+			terminated: undefined,
 			definitions: oldScope.definitions.createChild()
 		};
 
@@ -4064,7 +4364,7 @@ class JavascriptParser extends Parser {
 			this.undefineVariable("this");
 		}
 
-		this.enterPatterns(params, ident => {
+		this.enterPatterns(params, (ident) => {
 			this.defineVariable(ident);
 		});
 
@@ -4074,10 +4374,11 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
-	 * @param {function(): void} fn inner function
+	 * @param {() => void} fn inner function
+	 * @param {boolean} inExecutedPath executed state
 	 * @returns {void}
 	 */
-	inBlockScope(fn) {
+	inBlockScope(fn, inExecutedPath = false) {
 		const oldScope = this.scope;
 		this.scope = {
 			topLevelScope: oldScope.topLevelScope,
@@ -4086,16 +4387,23 @@ class JavascriptParser extends Parser {
 			inTaggedTemplateTag: false,
 			isStrict: oldScope.isStrict,
 			isAsmJs: oldScope.isAsmJs,
+			terminated: oldScope.terminated,
 			definitions: oldScope.definitions.createChild()
 		};
 
 		fn();
 
+		const terminated = this.scope.terminated;
+
+		if (inExecutedPath && terminated) {
+			oldScope.terminated = terminated;
+		}
+
 		this.scope = oldScope;
 	}
 
 	/**
-	 * @param {Array<Directive | Statement | ModuleDeclaration>} statements statements
+	 * @param {(Directive | Statement | ModuleDeclaration)[]} statements statements
 	 */
 	detectMode(statements) {
 		const isLiteral =
@@ -4228,7 +4536,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
-	 * @param {Expression | SpreadElement | PrivateIdentifier} expression expression node
+	 * @param {Expression | SpreadElement | PrivateIdentifier | Super} expression expression node
 	 * @returns {BasicEvaluatedExpression} evaluation result
 	 */
 	evaluateExpression(expression) {
@@ -4242,6 +4550,7 @@ class JavascriptParser extends Parser {
 				}
 			}
 		} catch (err) {
+			// eslint-disable-next-line no-console
 			console.warn(err);
 			// ignore error
 		}
@@ -4272,9 +4581,11 @@ class JavascriptParser extends Parser {
 		);
 	}
 
+	/** @typedef {{ range?: Range, value: string, code: boolean, conditional: false | CalculatedStringResult[] }} CalculatedStringResult */
+
 	/**
 	 * @param {Expression} expression expression
-	 * @returns {{ range?: Range, value: string, code: boolean, conditional: TODO }} result
+	 * @returns {CalculatedStringResult} result
 	 */
 	parseCalculatedString(expression) {
 		switch (expression.type) {
@@ -4322,6 +4633,7 @@ class JavascriptParser extends Parser {
 			case "ConditionalExpression": {
 				const consequent = this.parseCalculatedString(expression.consequent);
 				const alternate = this.parseCalculatedString(expression.alternate);
+				/** @type {CalculatedStringResult[]} */
 				const items = [];
 				if (consequent.conditional) {
 					items.push(...consequent.conditional);
@@ -4366,26 +4678,44 @@ class JavascriptParser extends Parser {
 	 * @returns {ParserState} the parser state
 	 */
 	parse(source, state) {
-		let ast;
-		/** @type {import("acorn").Comment[]} */
-		let comments;
-		const semicolons = new Set();
 		if (source === null) {
 			throw new Error("source must not be null");
 		}
+
 		if (Buffer.isBuffer(source)) {
-			source = source.toString("utf-8");
+			source = source.toString("utf8");
 		}
+
+		let ast;
+		/** @type {Comment[]} */
+		let comments;
+		/** @type {Set<number>} */
+		let semicolons;
+
 		if (typeof source === "object") {
+			semicolons = new Set();
+
 			ast = /** @type {Program} */ (source);
 			comments = source.comments;
+			if (source.semicolons) {
+				// Forward semicolon information from the preparsed AST if present
+				// This ensures the output is consistent with that of a fresh AST
+				for (const pos of source.semicolons) {
+					semicolons.add(pos);
+				}
+			}
 		} else {
-			comments = [];
-			ast = JavascriptParser._parse(source, {
-				sourceType: this.sourceType,
-				onComment: comments,
-				onInsertedSemicolon: pos => semicolons.add(pos)
-			});
+			({ ast, comments, semicolons } = JavascriptParser._parse(
+				source,
+				{
+					sourceType: this.sourceType,
+					locations: true,
+					ranges: true,
+					comments: true,
+					semicolons: true
+				},
+				this.options.parse
+			));
 		}
 
 		const oldScope = this.scope;
@@ -4401,9 +4731,9 @@ class JavascriptParser extends Parser {
 			inTaggedTemplateTag: false,
 			isStrict: false,
 			isAsmJs: false,
+			terminated: undefined,
 			definitions: new StackedMap()
 		};
-		/** @type {ParserState} */
 		this.state = state;
 		this.comments = comments;
 		this.semicolons = semicolons;
@@ -4412,6 +4742,7 @@ class JavascriptParser extends Parser {
 		if (this.hooks.program.call(ast, comments) === undefined) {
 			this.destructuringAssignmentProperties = new WeakMap();
 			this.detectMode(ast.body);
+			this.modulePreWalkStatements(ast.body);
 			this.preWalkStatements(ast.body);
 			this.prevStatement = undefined;
 			this.blockPreWalkStatements(ast.body);
@@ -4421,7 +4752,6 @@ class JavascriptParser extends Parser {
 		}
 		this.hooks.finish.call(ast, comments);
 		this.scope = oldScope;
-		/** @type {ParserState} */
 		this.state = oldState;
 		this.comments = oldComments;
 		this.semicolons = oldSemicolons;
@@ -4435,10 +4765,11 @@ class JavascriptParser extends Parser {
 	 * @returns {BasicEvaluatedExpression} evaluation result
 	 */
 	evaluate(source) {
-		const ast = JavascriptParser._parse(`(${source})`, {
-			sourceType: this.sourceType,
-			locations: false
-		});
+		const { ast } = JavascriptParser._parse(
+			`(${source})`,
+			{ sourceType: this.sourceType },
+			this.options.parse
+		);
 		if (ast.body.length !== 1 || ast.body[0].type !== "ExpressionStatement") {
 			throw new Error("evaluate: Source is not a expression");
 		}
@@ -4446,7 +4777,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
-	 * @param {Expression | Declaration | PrivateIdentifier | null | undefined} expr an expression
+	 * @param {Expression | Declaration | PrivateIdentifier | MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration | null | undefined} expr an expression
 	 * @param {number} commentsStartPos source position from which annotation comments are checked
 	 * @returns {boolean} true, when the expression is pure
 	 */
@@ -4467,14 +4798,20 @@ class JavascriptParser extends Parser {
 				) {
 					return false;
 				}
-				const items =
-					/** @type {TODO[]} */
-					(expr.body.body);
-				return items.every(item => {
+				const items = expr.body.body;
+				return items.every((item) => {
+					if (item.type === "StaticBlock") {
+						return false;
+					}
+
 					if (
 						item.computed &&
 						item.key &&
-						!this.isPure(item.key, item.range[0])
+						!this.isPure(
+							item.key,
+							/** @type {Range} */
+							(item.range)[0]
+						)
 					) {
 						return false;
 					}
@@ -4484,16 +4821,14 @@ class JavascriptParser extends Parser {
 						item.value &&
 						!this.isPure(
 							item.value,
-							item.key ? item.key.range[1] : item.range[0]
+							item.key
+								? /** @type {Range} */ (item.key.range)[1]
+								: /** @type {Range} */ (item.range)[0]
 						)
 					) {
 						return false;
 					}
 
-					if (item.type === "StaticBlock") {
-						return false;
-					}
-
 					if (
 						expr.superClass &&
 						item.type === "MethodDefinition" &&
@@ -4517,7 +4852,7 @@ class JavascriptParser extends Parser {
 				return true;
 
 			case "VariableDeclaration":
-				return expr.declarations.every(decl =>
+				return expr.declarations.every((decl) =>
 					this.isPure(decl.init, /** @type {Range} */ (decl.range)[0])
 				);
 
@@ -4541,7 +4876,7 @@ class JavascriptParser extends Parser {
 				);
 
 			case "SequenceExpression":
-				return expr.expressions.every(expr => {
+				return expr.expressions.every((expr) => {
 					const pureFlag = this.isPure(expr, commentsStartPos);
 					commentsStartPos = /** @type {Range} */ (expr.range)[1];
 					return pureFlag;
@@ -4554,13 +4889,13 @@ class JavascriptParser extends Parser {
 						commentsStartPos,
 						/** @type {Range} */ (expr.range)[0]
 					]).some(
-						comment =>
+						(comment) =>
 							comment.type === "Block" &&
 							/^\s*(#|@)__PURE__\s*$/.test(comment.value)
 					);
 				if (!pureFlag) return false;
 				commentsStartPos = /** @type {Range} */ (expr.callee.range)[1];
-				return expr.arguments.every(arg => {
+				return expr.arguments.every((arg) => {
 					if (arg.type === "SpreadElement") return false;
 					const pureFlag = this.isPure(arg, commentsStartPos);
 					commentsStartPos = /** @type {Range} */ (arg.range)[1];
@@ -4666,8 +5001,8 @@ class JavascriptParser extends Parser {
 
 	/**
 	 * @param {string} name name
-	 * @param {symbol} tag tag info
-	 * @returns {TODO} tag data
+	 * @param {Tag} tag tag info
+	 * @returns {TagData | undefined} tag data
 	 */
 	getTagData(name, tag) {
 		const info = this.scope.definitions.get(name);
@@ -4682,27 +5017,33 @@ class JavascriptParser extends Parser {
 
 	/**
 	 * @param {string} name name
-	 * @param {symbol} tag tag info
-	 * @param {TODO=} data data
+	 * @param {Tag} tag tag info
+	 * @param {TagData=} data data
+	 * @param {VariableInfoFlagsType=} flags flags
 	 */
-	tagVariable(name, tag, data) {
+	tagVariable(name, tag, data, flags = VariableInfoFlags.Tagged) {
 		const oldInfo = this.scope.definitions.get(name);
 		/** @type {VariableInfo} */
 		let newInfo;
 		if (oldInfo === undefined) {
-			newInfo = new VariableInfo(this.scope, name, {
+			newInfo = new VariableInfo(this.scope, name, flags, {
 				tag,
 				data,
 				next: undefined
 			});
 		} else if (oldInfo instanceof VariableInfo) {
-			newInfo = new VariableInfo(oldInfo.declaredScope, oldInfo.freeName, {
-				tag,
-				data,
-				next: oldInfo.tagInfo
-			});
+			newInfo = new VariableInfo(
+				oldInfo.declaredScope,
+				oldInfo.name,
+				/** @type {VariableInfoFlagsType} */ (oldInfo.flags | flags),
+				{
+					tag,
+					data,
+					next: oldInfo.tagInfo
+				}
+			);
 		} else {
-			newInfo = new VariableInfo(oldInfo, true, {
+			newInfo = new VariableInfo(oldInfo, name, flags, {
 				tag,
 				data,
 				next: undefined
@@ -4717,8 +5058,12 @@ class JavascriptParser extends Parser {
 	defineVariable(name) {
 		const oldInfo = this.scope.definitions.get(name);
 		// Don't redefine variable in same scope to keep existing tags
-		if (oldInfo instanceof VariableInfo && oldInfo.declaredScope === this.scope)
+		if (
+			oldInfo instanceof VariableInfo &&
+			oldInfo.declaredScope === this.scope
+		) {
 			return;
+		}
 		this.scope.definitions.set(name, this.scope);
 	}
 
@@ -4737,14 +5082,14 @@ class JavascriptParser extends Parser {
 		const info = this.scope.definitions.get(name);
 		if (info === undefined) return false;
 		if (info instanceof VariableInfo) {
-			return info.freeName === true;
+			return !info.isFree();
 		}
 		return true;
 	}
 
 	/**
 	 * @param {string} name variable name
-	 * @returns {string | ExportedVariableInfo} info for this variable
+	 * @returns {ExportedVariableInfo} info for this variable
 	 */
 	getVariableInfo(name) {
 		const value = this.scope.definitions.get(name);
@@ -4756,7 +5101,7 @@ class JavascriptParser extends Parser {
 
 	/**
 	 * @param {string} name variable name
-	 * @param {string | ExportedVariableInfo} variableInfo new info for this variable
+	 * @param {ExportedVariableInfo} variableInfo new info for this variable
 	 * @returns {void}
 	 */
 	setVariable(name, variableInfo) {
@@ -4766,7 +5111,12 @@ class JavascriptParser extends Parser {
 			} else {
 				this.scope.definitions.set(
 					name,
-					new VariableInfo(this.scope, variableInfo, undefined)
+					new VariableInfo(
+						this.scope,
+						variableInfo,
+						VariableInfoFlags.Free,
+						undefined
+					)
 				);
 			}
 		} else {
@@ -4779,19 +5129,24 @@ class JavascriptParser extends Parser {
 	 * @returns {VariableInfo} variable info
 	 */
 	evaluatedVariable(tagInfo) {
-		return new VariableInfo(this.scope, undefined, tagInfo);
+		return new VariableInfo(
+			this.scope,
+			undefined,
+			VariableInfoFlags.Evaluated,
+			tagInfo
+		);
 	}
 
 	/**
 	 * @param {Range} range range of the comment
-	 * @returns {{ options: Record<string, any> | null, errors: (Error & { comment: Comment })[] | null }} result
+	 * @returns {{ options: Record<string, EXPECTED_ANY> | null, errors: (Error & { comment: Comment })[] | null }} result
 	 */
 	parseCommentOptions(range) {
 		const comments = this.getComments(range);
 		if (comments.length === 0) {
 			return EMPTY_COMMENT_OPTIONS;
 		}
-		/** @type {Record<string, EXPECTED_ANY> } */
+		/** @type {Record<string, EXPECTED_ANY>} */
 		const options = {};
 		/** @type {(Error & { comment: Comment })[]} */
 		const errors = [];
@@ -4827,7 +5182,7 @@ class JavascriptParser extends Parser {
 
 	/**
 	 * @param {Expression | Super} expression a member expression
-	 * @returns {{ members: string[], object: Expression | Super, membersOptionals: boolean[], memberRanges: Range[] }} member names (reverse order) and remaining object
+	 * @returns {{ members: Members, object: Expression | Super, membersOptionals: MembersOptionals, memberRanges: MemberRanges }} member names (reverse order) and remaining object
 	 */
 	extractMemberExpressionChain(expression) {
 		/** @type {Node} */
@@ -4864,9 +5219,27 @@ class JavascriptParser extends Parser {
 	getFreeInfoFromVariable(varName) {
 		const info = this.getVariableInfo(varName);
 		let name;
-		if (info instanceof VariableInfo) {
-			name = info.freeName;
-			if (typeof name !== "string") return;
+		if (info instanceof VariableInfo && info.name) {
+			if (!info.isFree()) return;
+			name = info.name;
+		} else if (typeof info !== "string") {
+			return;
+		} else {
+			name = info;
+		}
+		return { info, name };
+	}
+
+	/**
+	 * @param {string} varName variable name
+	 * @returns {{name: string, info: VariableInfo | string} | undefined} name of the free variable and variable info for that
+	 */
+	getNameInfoFromVariable(varName) {
+		const info = this.getVariableInfo(varName);
+		let name;
+		if (info instanceof VariableInfo && info.name) {
+			if (!info.isFree() && !info.isTagged()) return;
+			name = info.name;
 		} else if (typeof info !== "string") {
 			return;
 		} else {
@@ -4875,8 +5248,8 @@ class JavascriptParser extends Parser {
 		return { info, name };
 	}
 
-	/** @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 */
+	/** @typedef {{ type: "call", call: CallExpression, calleeName: string, rootInfo: string | VariableInfo, getCalleeMembers: () => CalleeMembers, name: string, getMembers: () => Members, getMembersOptionals: () => MembersOptionals, getMemberRanges: () => MemberRanges }} CallExpressionInfo */
+	/** @typedef {{ type: "expression", rootInfo: string | VariableInfo, name: string, getMembers: () => Members, getMembersOptionals: () => MembersOptionals, getMemberRanges: () => MemberRanges }} ExpressionExpressionInfo */
 
 	/**
 	 * @param {Expression | Super} expression a member expression
@@ -4897,7 +5270,7 @@ class JavascriptParser extends Parser {
 				}
 				const rootName = getRootName(callee);
 				if (!rootName) return;
-				const result = this.getFreeInfoFromVariable(rootName);
+				const result = this.getNameInfoFromVariable(rootName);
 				if (!result) return;
 				const { info: rootInfo, name: resolvedRoot } = result;
 				const calleeName = objectAndMembersToName(resolvedRoot, rootMembers);
@@ -4920,7 +5293,7 @@ class JavascriptParser extends Parser {
 				const rootName = getRootName(object);
 				if (!rootName) return;
 
-				const result = this.getFreeInfoFromVariable(rootName);
+				const result = this.getNameInfoFromVariable(rootName);
 				if (!result) return;
 				const { info: rootInfo, name: resolvedRoot } = result;
 				return {
@@ -4936,8 +5309,8 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
-	 * @param {MemberExpression} expression an expression
-	 * @returns {{ name: string, rootInfo: ExportedVariableInfo, getMembers: () => string[]} | undefined} name info
+	 * @param {Expression} expression an expression
+	 * @returns {{ name: string, rootInfo: ExportedVariableInfo, getMembers: () => Members } | undefined} name info
 	 */
 	getNameForExpression(expression) {
 		return this.getMemberExpressionInfo(
@@ -4946,27 +5319,84 @@ class JavascriptParser extends Parser {
 		);
 	}
 
+	/**
+	 * @param {Compilation} compilation compilation
+	 * @param {Module} module module
+	 * @returns {ParseFunction | undefined} parser
+	 */
+	static _getModuleParseFunction(compilation, module) {
+		// Get from module if available
+		if (
+			module instanceof NormalModule &&
+			module.parser instanceof JavascriptParser
+		) {
+			return module.parser.options.parse;
+		}
+
+		// Fallback to the global javascript parse function
+		if (typeof compilation.options.module.parser.javascript !== "undefined") {
+			return compilation.options.module.parser.javascript.parse;
+		}
+	}
+
 	/**
 	 * @param {string} code source code
-	 * @param {ParseOptions} options parsing options
-	 * @returns {Program} parsed ast
+	 * @param {InternalParseOptions} options parsing options
+	 * @param {ParseFunction=} customParse custom function to parse
+	 * @returns {ParseResult} parse result
 	 */
-	static _parse(code, options) {
+	static _parse(code, options, customParse) {
 		const type = options ? options.sourceType : "module";
-		/** @type {AcornOptions} */
+		/** @type {ParseOptions} */
 		const parserOptions = {
 			...defaultParserOptions,
 			allowReturnOutsideFunction: type === "script",
 			...options,
 			sourceType: type === "auto" ? "module" : type
 		};
+		/**
+		 * @param {string} code source code
+		 * @param {ParseOptions} options parsing options
+		 * @returns {ParseResult} parse result
+		 */
+		const internalParse = (code, options) => {
+			if (typeof customParse === "function") {
+				return customParse(code, options);
+			}
+
+			/** @type {Comment[]} */
+			const comments = [];
+
+			if (options.comments) {
+				/** @type {AcornOptions} */
+				(options).onComment = comments;
+			}
+
+			/** @type {Set<number>} */
+			const semicolons = new Set();
+
+			if (options.semicolons) {
+				/** @type {AcornOptions} */
+				(options).onInsertedSemicolon = (pos) => semicolons.add(pos);
+			}
+
+			const ast =
+				/** @type {Program} */
+				(parser.parse(code, /** @type {AcornOptions} */ (options)));
+
+			return { ast, comments, semicolons };
+		};
 
-		/** @type {import("acorn").Program | undefined} */
+		/** @type {Program | undefined} */
 		let ast;
+		/** @type {Comment[] | undefined} */
+		let comments;
+		/** @type {Set<number> | undefined} */
+		let semicolons;
 		let error;
 		let threw = false;
 		try {
-			ast = parser.parse(code, parserOptions);
+			({ ast, comments, semicolons } = internalParse(code, parserOptions));
 		} catch (err) {
 			error = err;
 			threw = true;
@@ -4974,14 +5404,10 @@ class JavascriptParser extends Parser {
 
 		if (threw && type === "auto") {
 			parserOptions.sourceType = "script";
-			if (!("allowReturnOutsideFunction" in options)) {
-				parserOptions.allowReturnOutsideFunction = true;
-			}
-			if (Array.isArray(parserOptions.onComment)) {
-				parserOptions.onComment.length = 0;
-			}
+			parserOptions.allowReturnOutsideFunction = true;
+
 			try {
-				ast = parser.parse(code, parserOptions);
+				({ ast, comments, semicolons } = internalParse(code, parserOptions));
 				threw = false;
 			} catch (_err) {
 				// we use the error from first parse try
@@ -4993,15 +5419,25 @@ class JavascriptParser extends Parser {
 			throw error;
 		}
 
-		return /** @type {Program} */ (ast);
+		return /** @type {ParseResult} */ ({ ast, comments, semicolons });
+	}
+
+	/**
+	 * @param {((BaseParser: typeof AcornParser) => typeof AcornParser)[]} plugins parser plugin
+	 * @returns {typeof JavascriptParser} parser
+	 */
+	static extend(...plugins) {
+		parser = parser.extend(...plugins);
+		return JavascriptParser;
 	}
 }
 
 module.exports = JavascriptParser;
 module.exports.ALLOWED_MEMBER_TYPES_ALL = ALLOWED_MEMBER_TYPES_ALL;
-module.exports.ALLOWED_MEMBER_TYPES_EXPRESSION =
-	ALLOWED_MEMBER_TYPES_EXPRESSION;
 module.exports.ALLOWED_MEMBER_TYPES_CALL_EXPRESSION =
 	ALLOWED_MEMBER_TYPES_CALL_EXPRESSION;
-module.exports.getImportAttributes = getImportAttributes;
+module.exports.ALLOWED_MEMBER_TYPES_EXPRESSION =
+	ALLOWED_MEMBER_TYPES_EXPRESSION;
 module.exports.VariableInfo = VariableInfo;
+module.exports.VariableInfoFlags = VariableInfoFlags;
+module.exports.getImportAttributes = getImportAttributes;