@depup/webpack 5.106.1-depup.0 → 5.109.2-depup.0

package/lib/javascript/JavascriptParser.js

@@ -5,20 +5,27 @@
 
 "use strict";
 
-const vm = require("vm");
-const { Parser: AcornParser, tokTypes } = require("acorn");
 const { HookMap, SyncBailHook } = require("tapable");
 const NormalModule = require("../NormalModule");
 const Parser = require("../Parser");
+const WebpackError = require("../WebpackError");
 const StackedMap = require("../util/StackedMap");
-const binarySearchBounds = require("../util/binarySearchBounds");
 const {
+	CompilerHintNotationRegExp,
 	createMagicCommentContext,
-	webpackCommentRegExp
+	getCommentsInRange,
+	parseCommentOptionsInRange
 } = require("../util/magicComment");
-const memoize = require("../util/memoize");
 const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
-
+const {
+	LEGACY_ASSERT_ATTRIBUTES,
+	WebpackParser,
+	buildLineStarts,
+	hasOctalEscape,
+	positionAt
+} = require("./syntax");
+
+/** @typedef {typeof import("acorn").Parser} AcornParser */
 /** @typedef {import("acorn").Options} AcornOptions */
 /** @typedef {import("acorn").ecmaVersion} EcmaVersion */
 /** @typedef {import("estree").AssignmentExpression} AssignmentExpression */
@@ -32,7 +39,9 @@ const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
 /** @typedef {import("estree").SwitchStatement} SwitchStatement */
 /** @typedef {import("estree").ClassExpression} ClassExpression */
 /** @typedef {import("estree").SourceLocation} SourceLocation */
-/** @typedef {import("estree").Comment & { start: number, end: number, loc: SourceLocation }} Comment */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../Dependency").SourcePosition} SourcePosition */
+/** @typedef {import("estree").Comment & { start: number, end: number, loc?: SourceLocation | null }} Comment */
 /** @typedef {import("estree").ConditionalExpression} ConditionalExpression */
 /** @typedef {import("estree").Declaration} Declaration */
 /** @typedef {import("estree").PrivateIdentifier} PrivateIdentifier */
@@ -94,6 +103,7 @@ const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
 /** @typedef {import("estree").MaybeNamedFunctionDeclaration} MaybeNamedFunctionDeclaration */
 /** @typedef {import("estree").MaybeNamedClassDeclaration} MaybeNamedClassDeclaration */
 /**
+ * Defines the shared type used by this module.
  * @template T
  * @typedef {import("tapable").AsArray<T>} AsArray<T>
  */
@@ -104,6 +114,7 @@ const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
 /** @typedef {import("../dependencies/HarmonyExportImportedSpecifierDependency").HarmonyStarExportsList} HarmonyStarExportsList */
 
 /**
+ * Defines the known javascript parser state type used by this module.
  * @typedef {object} KnownJavascriptParserState
  * @property {Set<string>=} harmonyNamedExports
  * @property {HarmonyStarExportsList=} harmonyStarExports
@@ -117,6 +128,7 @@ const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
 /** @typedef {import("../Module")} Module */
 
 /** @typedef {{ name: string | VariableInfo, rootInfo: string | VariableInfo, getMembers: () => Members, getMembersOptionals: () => MembersOptionals, getMemberRanges: () => MemberRanges }} GetInfoResult */
+/** @typedef {{ consequent?: EXPECTED_OBJECT, alternate?: EXPECTED_OBJECT }} GuardCollection per-branch guard frames pushed onto the parser state guard stack */
 /** @typedef {Statement | ModuleDeclaration | Expression | MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration} StatementPathItem */
 /** @typedef {(ident: string) => void} OnIdentString */
 /** @typedef {(ident: string, identifier: Identifier) => void} OnIdent */
@@ -124,86 +136,52 @@ const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
 
 /** @typedef {Set<DestructuringAssignmentProperty>} DestructuringAssignmentProperties */
 
-// TODO remove cast when @types/estree has been updated to import assertions
+// TODO remove cast when @types/estree has been updated to import phases
 /** @typedef {import("estree").ImportExpression & { phase?: "defer" | "source" }} ImportExpression */
 
 /** @type {string[]} */
 const EMPTY_ARRAY = [];
+
+/**
+ * Getter that reverses `arr` in place on first access and caches it. Lighter
+ * than `memoize(() => arr.reverse())` (one closure instead of two) and called
+ * per member expression on hot parse paths.
+ * @template T
+ * @param {T[]} arr array reversed lazily on first access
+ * @returns {() => T[]} getter returning the reversed array
+ */
+const lazyReverse = (arr) => {
+	let reversed = false;
+	return () => {
+		if (!reversed) {
+			arr.reverse();
+			reversed = true;
+		}
+		return arr;
+	};
+};
+
 const ALLOWED_MEMBER_TYPES_CALL_EXPRESSION = 0b01;
 const ALLOWED_MEMBER_TYPES_EXPRESSION = 0b10;
 const ALLOWED_MEMBER_TYPES_ALL = 0b11;
 
-const LEGACY_ASSERT_ATTRIBUTES = Symbol("assert");
-
-/** @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 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 {Record<string, boolean>} */
-			const attributeKeys = {};
-			let first = true;
-
-			while (!this.eat(tokTypes.braceR)) {
-				if (!first) {
-					this.expect(tokTypes.comma);
-					if (this.afterTrailingComma(tokTypes.braceR)) {
-						break;
-					}
-				} else {
-					first = false;
-				}
-
-				const attr =
-					/** @type {ImportAttribute} */
-					this.parseImportAttribute();
-				const keyName =
-					attr.key.type === "Identifier" ? attr.key.name : attr.key.value;
-
-				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;
-			}
+// Shared `() => false` so the members-optionals fallback in walkCallExpression
+// doesn't allocate a fresh closure per identifier-rooted call.
+const RETURN_FALSE = () => false;
 
-			return nodes;
-		}
-	};
+// Shared `() => []` for the member-less identifier/this evaluation results,
+// replacing three fresh closures per evaluated free variable.
+const RETURN_EMPTY_ARRAY = () => [];
 
 // Syntax: https://developer.mozilla.org/en/SpiderMonkey/Parser_API
-let parser = AcornParser.extend(importAssertions);
+let parser = /** @type {AcornParser} */ (WebpackParser);
 
 /** @typedef {Record<string, string> & { _isLegacyAssert?: boolean }} ImportAttributes */
 
+// Conceptually pairs with ./syntax's LEGACY_ASSERT_ATTRIBUTES marker, but is
+// pinned here by its public `JavascriptParser.getImportAttributes` typing.
 /**
+ * Gets import attributes.
  * @param {ImportDeclaration | ExportNamedDeclaration | ExportAllDeclaration | ImportExpression} node node with assertions
  * @returns {ImportAttributes | undefined} import attributes
  */
@@ -287,19 +265,25 @@ const VariableInfoFlags = Object.freeze({
 
 class VariableInfo {
 	/**
+	 * Creates an instance of VariableInfo.
 	 * @param {ScopeInfo} declaredScope scope in which the variable is declared
 	 * @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, name, flags, tagInfo) {
+		/** @type {ScopeInfo} */
 		this.declaredScope = declaredScope;
+		/** @type {string | undefined} */
 		this.name = name;
+		/** @type {VariableInfoFlagsType} */
 		this.flags = flags;
+		/** @type {TagInfo | undefined} */
 		this.tagInfo = tagInfo;
 	}
 
 	/**
+	 * Checks whether this variable info is free.
 	 * @returns {boolean} the variable is free or not
 	 */
 	isFree() {
@@ -307,6 +291,7 @@ class VariableInfo {
 	}
 
 	/**
+	 * Checks whether this variable info is tagged.
 	 * @returns {boolean} the variable is tagged by tagVariable or not
 	 */
 	isTagged() {
@@ -318,45 +303,51 @@ class VariableInfo {
 /** @typedef {Literal | string | null | undefined} ImportSource */
 
 /**
+ * Defines the internal parse options type used by this module.
  * @typedef {Omit<ParseOptions, "sourceType" | "ecmaVersion"> & { sourceType: "module" | "script" | "auto" }} InternalParseOptions
  */
 
 /**
+ * Defines the parse options type used by this module.
  * @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
+ * @property {boolean=} lazyNodes internal: serve `range` lazily and skip acorn's location/range tracking
+ * @property {Comment[]=} lazyComments internal: collect comments here without slicing their text eagerly
+ * @property {boolean=} importPhases enable parsing of the import phase proposals (import defer / import source)
+ * @property {boolean=} moduleFallback internal: for `auto`, let the parser downgrade module->script in place instead of re-parsing
  */
 
 /**
+ * Defines the parse result type used by this module.
  * @typedef {object} ParseResult
  * @property {Program} ast
  * @property {Comment[]} comments
- * @property {Set<number>} semicolons
  */
 
 /**
+ * Defines the parse function type used by this module.
  * @typedef {(code: string, options: ParseOptions) => ParseResult} ParseFunction
  */
 
 /** @typedef {symbol} Tag */
 
 /** @typedef {import("../dependencies/HarmonyImportDependencyParserPlugin").HarmonySettings} HarmonySettings */
-/** @typedef {import("../dependencies/HarmonyImportDependencyParserPlugin").HarmonySpecifierGuards} HarmonySpecifierGuards */
 /** @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 | HarmonySpecifierGuards} KnownTagData */
+/** @typedef {HarmonySettings | ImportSettings | CommonJsImportSettings | TopLevelSymbol | CompatibilitySettings} KnownTagData */
 /** @typedef {KnownTagData | Record<string, EXPECTED_ANY>} TagData */
 
 /**
+ * Defines the tag info type used by this module.
  * @typedef {object} TagInfo
  * @property {Tag} tag
  * @property {TagData=} data
@@ -372,6 +363,7 @@ const SCOPE_INFO_TERMINATED_RETURN = 1;
 const SCOPE_INFO_TERMINATED_THROW = 2;
 
 /**
+ * Defines the scope info type used by this module.
  * @typedef {object} ScopeInfo
  * @property {StackedMap<string, VariableInfo | ScopeInfo>} definitions
  * @property {boolean | "arrow"} topLevelScope
@@ -386,10 +378,11 @@ const SCOPE_INFO_TERMINATED_THROW = 2;
 /** @typedef {[number, number]} Range */
 
 /**
+ * Defines the destructuring assignment property type used by this module.
+ * Carries only the range — consumers derive line/column via `getLocation`.
  * @typedef {object} DestructuringAssignmentProperty
  * @property {string} id
  * @property {Range} range
- * @property {SourceLocation} loc
  * @property {Set<DestructuringAssignmentProperty> | undefined=} pattern
  * @property {boolean | string} shorthand
  */
@@ -459,6 +452,25 @@ const getRootName = (expression) => {
 	}
 };
 
+/**
+ * @param {string} type AST node type
+ * @returns {boolean} true for FunctionExpression or ArrowFunctionExpression
+ */
+const isFunctionExpression = (type) =>
+	type === "FunctionExpression" || type === "ArrowFunctionExpression";
+
+/**
+ * @param {FunctionExpression | ArrowFunctionExpression} fn function
+ * @returns {boolean} true when all params are plain identifiers
+ */
+const isSimpleFunction = (fn) => {
+	const params = fn.params;
+	for (let i = 0; i < params.length; i++) {
+		if (params[i].type !== "Identifier") return false;
+	}
+	return true;
+};
+
 /** @type {ParseOptions} */
 const defaultParserOptions = {
 	sourceType: "module",
@@ -470,17 +482,24 @@ const defaultParserOptions = {
 	allowHashBang: true
 };
 
-const EMPTY_COMMENT_OPTIONS = {
-	options: null,
-	errors: null
-};
+// reused by _parse for every non-custom parse — all fields are reset per parse
+/** @type {ParseOptions} */
+const REUSED_PARSER_OPTIONS = { ...defaultParserOptions };
+
+// Read-only snippet ASTs for `evaluate()`, released with the compilation;
+// DefinePlugin evaluates the same strings once per usage per module.
+/** @type {WeakMap<Compilation, Map<string, Program>>} */
+const evaluateAstCaches = new WeakMap();
+// The inner map is strong while the compilation lives, so cap it
+const EVALUATE_AST_CACHE_LIMIT = 4096;
 
 const CLASS_NAME = "JavascriptParser";
 
 class JavascriptParser extends Parser {
 	/**
+	 * Creates an instance of JavascriptParser.
 	 * @param {"module" | "script" | "auto"=} sourceType default source type
-	 * @param {{ parse?: ParseFunction }=} options parser options
+	 * @param {{ parse?: ParseFunction, typescript?: boolean, importPhases?: boolean, strictModeViolations?: "error" | "warn" | false }=} options parser options
 	 */
 	constructor(sourceType = "auto", options = {}) {
 		super();
@@ -495,11 +514,17 @@ class JavascriptParser extends Parser {
 			evaluateDefinedIdentifier: new HookMap(
 				() => new SyncBailHook(["expression"])
 			),
-			/** @type {HookMap<SyncBailHook<[NewExpression], BasicEvaluatedExpression | null | undefined>>} */
+			/**
+			 * @type {HookMap<SyncBailHook<[NewExpression], BasicEvaluatedExpression | null | undefined>>}
+			 * @since 5.73.0
+			 */
 			evaluateNewExpression: new HookMap(
 				() => new SyncBailHook(["expression"])
 			),
-			/** @type {HookMap<SyncBailHook<[CallExpression], BasicEvaluatedExpression | null | undefined>>} */
+			/**
+			 * @type {HookMap<SyncBailHook<[CallExpression], BasicEvaluatedExpression | null | undefined>>}
+			 * @since 5.73.0
+			 */
 			evaluateCallExpression: new HookMap(
 				() => new SyncBailHook(["expression"])
 			),
@@ -513,14 +538,29 @@ class JavascriptParser extends Parser {
 			),
 			/** @type {SyncBailHook<[Statement | ModuleDeclaration | MaybeNamedClassDeclaration | MaybeNamedFunctionDeclaration], boolean | void>} */
 			preStatement: new SyncBailHook(["statement"]),
+			/**
+			 * @type {HookMap<SyncBailHook<[Statement | ModuleDeclaration | MaybeNamedClassDeclaration | MaybeNamedFunctionDeclaration], boolean | void>>}
+			 * @since 5.109.0
+			 */
+			preStatementByType: new HookMap(() => new SyncBailHook(["statement"])),
 
 			/** @type {SyncBailHook<[Statement | ModuleDeclaration | MaybeNamedClassDeclaration | MaybeNamedFunctionDeclaration], boolean | void>} */
 			blockPreStatement: new SyncBailHook(["declaration"]),
+			/**
+			 * @type {HookMap<SyncBailHook<[Statement | ModuleDeclaration | MaybeNamedClassDeclaration | MaybeNamedFunctionDeclaration], boolean | void>>}
+			 * @since 5.109.0
+			 */
+			blockPreStatementByType: new HookMap(
+				() => new SyncBailHook(["declaration"])
+			),
 			/** @type {SyncBailHook<[Statement | ModuleDeclaration | MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration], boolean | void>} */
 			statement: new SyncBailHook(["statement"]),
 			/** @type {SyncBailHook<[IfStatement], boolean | void>} */
 			statementIf: new SyncBailHook(["statement"]),
-			/** @type {SyncBailHook<[Expression], ((walk: () => void) => void) | void>} */
+			/**
+			 * @type {SyncBailHook<[Expression], GuardCollection | void>}
+			 * @since 5.105.0
+			 */
 			collectGuards: new SyncBailHook(["expression"]),
 			/** @type {SyncBailHook<[Expression, ClassExpression | ClassDeclaration | MaybeNamedClassDeclaration], boolean | void>} */
 			classExtendsExpression: new SyncBailHook([
@@ -529,7 +569,10 @@ class JavascriptParser extends Parser {
 			]),
 			/** @type {SyncBailHook<[MethodDefinition | PropertyDefinition | StaticBlock, ClassExpression | ClassDeclaration | MaybeNamedClassDeclaration], boolean | void>} */
 			classBodyElement: new SyncBailHook(["element", "classDefinition"]),
-			/** @type {SyncBailHook<[Expression, MethodDefinition | PropertyDefinition, ClassExpression | ClassDeclaration | MaybeNamedClassDeclaration], boolean | void>} */
+			/**
+			 * @type {SyncBailHook<[Expression, MethodDefinition | PropertyDefinition, ClassExpression | ClassDeclaration | MaybeNamedClassDeclaration], boolean | void>}
+			 * @since 5.36.0
+			 */
 			classBodyValue: new SyncBailHook([
 				"expression",
 				"element",
@@ -569,7 +612,7 @@ class JavascriptParser extends Parser {
 				"exportName",
 				"index"
 			]),
-			/** @type {SyncBailHook<[VariableDeclarator, Statement], boolean | void>} */
+			/** @type {SyncBailHook<[VariableDeclarator, VariableDeclaration], boolean | void>} */
 			preDeclarator: new SyncBailHook(["declarator", "statement"]),
 			/** @type {SyncBailHook<[VariableDeclarator, Statement], boolean | void>} */
 			declarator: new SyncBailHook(["declarator", "statement"]),
@@ -579,13 +622,19 @@ class JavascriptParser extends Parser {
 			varDeclarationLet: new HookMap(() => new SyncBailHook(["declaration"])),
 			/** @type {HookMap<SyncBailHook<[Identifier], boolean | void>>} */
 			varDeclarationConst: new HookMap(() => new SyncBailHook(["declaration"])),
-			/** @type {HookMap<SyncBailHook<[Identifier], boolean | void>>} */
+			/**
+			 * @type {HookMap<SyncBailHook<[Identifier], boolean | void>>}
+			 * @since 5.100.0
+			 */
 			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>} */
+			/**
+			 * @type {SyncBailHook<[Expression], boolean | void>}
+			 * @since 5.101.3
+			 */
 			collectDestructuringAssignmentProperties: new SyncBailHook([
 				"expression"
 			]),
@@ -646,7 +695,10 @@ class JavascriptParser extends Parser {
 			optionalChaining: new SyncBailHook(["optionalChaining"]),
 			/** @type {HookMap<SyncBailHook<[NewExpression], boolean | void>>} */
 			new: new HookMap(() => new SyncBailHook(["expression"])),
-			/** @type {SyncBailHook<[BinaryExpression], boolean | void>} */
+			/**
+			 * @type {SyncBailHook<[BinaryExpression], boolean | void>}
+			 * @since 5.71.0
+			 */
 			binaryExpression: new SyncBailHook(["binaryExpression"]),
 			/** @type {HookMap<SyncBailHook<[Expression], boolean | void>>} */
 			expression: new HookMap(() => new SyncBailHook(["expression"])),
@@ -670,11 +722,17 @@ 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>} */
+			/**
+			 * @type {SyncBailHook<[ThrowStatement | ReturnStatement], boolean | void>}
+			 * @since 5.99.0
+			 */
 			terminate: new SyncBailHook(["statement"]),
 			/** @type {SyncBailHook<[Program, Comment[]], boolean | void>} */
 			finish: new SyncBailHook(["ast", "comments"]),
-			/** @type {SyncBailHook<[Statement], boolean | void>} */
+			/**
+			 * @type {SyncBailHook<[Statement], boolean | void>}
+			 * @since 5.99.9
+			 */
 			unusedStatement: new SyncBailHook(["statement"])
 		});
 		this.sourceType = sourceType;
@@ -686,7 +744,10 @@ class JavascriptParser extends Parser {
 		this.state = /** @type {EXPECTED_ANY} */ (undefined);
 		/** @type {Comment[] | undefined} */
 		this.comments = undefined;
-		/** @type {Set<number> | undefined} */
+		// ASI overrides keyed by statement-end offset: true forces an ASI
+		// position, false forces a real semicolon. Absent offsets are derived
+		// from the source text. Allocated lazily by set/unsetAsiPosition.
+		/** @type {Map<number, boolean> | undefined} */
 		this.semicolons = undefined;
 		/** @type {StatementPath | undefined} */
 		this.statementPath = undefined;
@@ -696,8 +757,39 @@ class JavascriptParser extends Parser {
 		this.destructuringAssignmentProperties = undefined;
 		/** @type {TagData | undefined} */
 		this.currentTagData = undefined;
+		// True while parsing a loose module whose code is emitted as strict ESM.
+		this._strictInModuleOutput = false;
+		// Source text of the current parse, for offset → line/column mapping.
+		/** @type {string | undefined} */
+		this._source = undefined;
+		// Offset of each line's first character, built on first getLocation use.
+		/** @type {number[] | undefined} */
+		this._lineStarts = undefined;
+		// True while only the parser's own taps sit on evaluate.for("Identifier");
+		// recomputed per parse, gates the defined-identifier fast paths.
+		this._evalIdentOwnTaps = false;
 		this.magicCommentContext = createMagicCommentContext();
+		// Reused for enterPatterns on every scope entry to avoid per-scope closures.
+		/** @type {OnIdentString} */
+		this._defineVariable = (ident) => this.defineVariable(ident);
 		this._initializeEvaluating();
+		// keyed taps are free for every other member chain, and a shadowed
+		// `arguments` binding never dispatches the free-variable hooks
+		this.hooks.expressionMemberChain
+			.for("arguments")
+			.tap(CLASS_NAME, (expression, members) => {
+				if (this._strictInModuleOutput) {
+					this._checkStrictModeArgumentsMember(members[0], expression);
+				}
+			});
+		this.hooks.callMemberChain
+			.for("arguments")
+			.tap(CLASS_NAME, (expression, members) => {
+				// longer chains re-enter the member walk, which reports them
+				if (this._strictInModuleOutput && members.length === 1) {
+					this._checkStrictModeArgumentsMember(members[0], expression);
+				}
+			});
 	}
 
 	_initializeEvaluating() {
@@ -956,6 +1048,7 @@ class JavascriptParser extends Parser {
 				(a === true && b === false) || (a === false && b === true);
 
 			/**
+			 * Handle template string compare.
 			 * @param {BasicEvaluatedExpression} left left
 			 * @param {BasicEvaluatedExpression} right right
 			 * @param {BasicEvaluatedExpression} res res
@@ -964,6 +1057,7 @@ class JavascriptParser extends Parser {
 			 */
 			const handleTemplateStringCompare = (left, right, res, eql) => {
 				/**
+				 * Returns value.
 				 * @param {BasicEvaluatedExpression[]} parts parts
 				 * @returns {string} value
 				 */
@@ -977,6 +1071,7 @@ class JavascriptParser extends Parser {
 					return value;
 				};
 				/**
+				 * Returns value.
 				 * @param {BasicEvaluatedExpression[]} parts parts
 				 * @returns {string} value
 				 */
@@ -1319,6 +1414,16 @@ class JavascriptParser extends Parser {
 				return handleConstOperation((l, r) => l <= r);
 			} else if (expr.operator === ">=") {
 				return handleConstOperation((l, r) => l >= r);
+			} else if (expr.operator === "in") {
+				// `x in y` always evaluates to a boolean, so it is never nullish
+				const left = this.evaluateExpression(expr.left);
+				const right = this.evaluateExpression(expr.right);
+				return new BasicEvaluatedExpression()
+					.setNullish(false)
+					.setSideEffects(
+						left.couldHaveSideEffects() || right.couldHaveSideEffects()
+					)
+					.setRange(/** @type {Range} */ (expr.range));
 			}
 		});
 		this.hooks.evaluate.for("UnaryExpression").tap(CLASS_NAME, (_expr) => {
@@ -1460,6 +1565,7 @@ class JavascriptParser extends Parser {
 			}
 		});
 		/**
+		 * Tap evaluate with variable info.
 		 * @param {"Identifier" | "ThisExpression" | "MemberExpression"} exprType expression type name
 		 * @param {(node: Expression | SpreadElement) => GetInfoResult | undefined} getInfo get info
 		 * @returns {void}
@@ -1474,15 +1580,16 @@ class JavascriptParser extends Parser {
 					/** @type {Identifier | ThisExpression | MemberExpression} */ (expr);
 
 				const info = getInfo(expression);
+				// Cache the result (even when undefined) so the stage-100 tap below
+				// reuses it instead of recomputing getInfo — getMemberExpressionInfo
+				// is expensive and previously ran twice for every rejected member.
+				cachedExpression = expression;
+				cachedInfo = info;
 				if (info !== undefined) {
 					return this.callHooksForInfoWithFallback(
 						this.hooks.evaluateIdentifier,
 						info.name,
-						(_name) => {
-							cachedExpression = expression;
-							cachedInfo = info;
-							return undefined;
-						},
+						(_name) => undefined,
 						(name) => {
 							const hook = this.hooks.evaluateDefinedIdentifier.get(name);
 							if (hook !== undefined) {
@@ -1522,14 +1629,18 @@ class JavascriptParser extends Parser {
 			const info = this.getVariableInfo(/** @type {Identifier} */ (expr).name);
 			if (
 				typeof info === "string" ||
-				(info instanceof VariableInfo && (info.isFree() || info.isTagged()))
+				(info instanceof VariableInfo &&
+					(info.isFree() ||
+						info.isTagged() ||
+						// Walk `tagInfo` in `callHooksForInfo` if tagInfo is present.
+						info.tagInfo !== undefined))
 			) {
 				return {
 					name: info,
 					rootInfo: info,
-					getMembers: () => [],
-					getMembersOptionals: () => [],
-					getMemberRanges: () => []
+					getMembers: RETURN_EMPTY_ARRAY,
+					getMembersOptionals: RETURN_EMPTY_ARRAY,
+					getMemberRanges: RETURN_EMPTY_ARRAY
 				};
 			}
 		});
@@ -1542,9 +1653,9 @@ class JavascriptParser extends Parser {
 				return {
 					name: info,
 					rootInfo: info,
-					getMembers: () => [],
-					getMembersOptionals: () => [],
-					getMemberRanges: () => []
+					getMembers: RETURN_EMPTY_ARRAY,
+					getMembersOptionals: RETURN_EMPTY_ARRAY,
+					getMemberRanges: RETURN_EMPTY_ARRAY
 				};
 			}
 		});
@@ -1565,8 +1676,8 @@ class JavascriptParser extends Parser {
 			)
 		);
 
-		this.hooks.evaluate.for("CallExpression").tap(CLASS_NAME, (_expr) => {
-			const expr = /** @type {CallExpression} */ (_expr);
+		this.hooks.evaluate.for("CallExpression").tap(CLASS_NAME, (expression) => {
+			const expr = /** @type {CallExpression} */ (expression);
 			if (
 				expr.callee.type === "MemberExpression" &&
 				expr.callee.property.type ===
@@ -1687,6 +1798,7 @@ class JavascriptParser extends Parser {
 		}
 
 		/**
+		 * Gets simplified template result.
 		 * @param {"cooked" | "raw"} kind kind of values to get
 		 * @param {TemplateLiteral} templateLiteralExpr TemplateLiteral expr
 		 * @returns {{ quasis: BasicEvaluatedExpression[], parts: BasicEvaluatedExpression[] }} Simplified template
@@ -1959,9 +2071,25 @@ class JavascriptParser extends Parser {
 			}
 			return this.evaluateExpression(expr.expression);
 		});
+		this.hooks.evaluate.for("SequenceExpression").tap(CLASS_NAME, (_expr) => {
+			const expr = /** @type {SequenceExpression} */ (_expr);
+			if (!expr.range) return;
+			let commentsStartPos = /** @type {Range} */ (expr.range)[0];
+			for (let i = 0; i < expr.expressions.length - 1; i++) {
+				const item = expr.expressions[i];
+				if (!item.range) return;
+				if (!this.isPure(item, commentsStartPos)) return;
+				commentsStartPos = /** @type {Range} */ (item.range)[1];
+			}
+			const last = expr.expressions[expr.expressions.length - 1];
+			const evaluated = this.evaluateExpression(last);
+			if (!evaluated.isCompileTimeValue()) return;
+			return evaluated.setRange(/** @type {Range} */ (expr.range));
+		});
 	}
 
 	/**
+	 * Destructuring assignment properties for.
 	 * @param {Expression} node node
 	 * @returns {DestructuringAssignmentProperties | undefined} destructured identifiers
 	 */
@@ -1971,10 +2099,20 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Gets rename identifier.
 	 * @param {Expression | SpreadElement} expr expression
 	 * @returns {string | VariableInfo | undefined} identifier
 	 */
 	getRenameIdentifier(expr) {
+		if (
+			expr.type === "Identifier" &&
+			this._evalIdentOwnTaps &&
+			expr.name !== "undefined" &&
+			this._isDefinedPlainVariable(expr.name)
+		) {
+			// the evaluation could only fall through — never an identifier result
+			return;
+		}
 		const result = this.evaluateExpression(expr);
 		if (result.isIdentifier()) {
 			return result.identifier;
@@ -1982,6 +2120,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Processes the provided classy.
 	 * @param {ClassExpression | ClassDeclaration | MaybeNamedClassDeclaration} classy a class node
 	 * @returns {void}
 	 */
@@ -2113,49 +2252,60 @@ class JavascriptParser extends Parser {
 	preWalkStatement(statement) {
 		/** @type {StatementPath} */
 		(this.statementPath).push(statement);
-		if (this.hooks.preStatement.call(statement)) {
+		const { preStatement, preStatementByType } = this.hooks;
+		// skip the broadcast entirely when nothing taps it; type-keyed taps
+		// only run for their statement type
+		let bail =
+			preStatement.taps.length !== 0 ? preStatement.call(statement) : undefined;
+		if (!bail) {
+			const typed = preStatementByType.get(statement.type);
+			if (typed !== undefined) bail = typed.call(statement);
+		}
+		if (bail) {
 			this.prevStatement =
 				/** @type {StatementPath} */
 				(this.statementPath).pop();
 			return;
 		}
+		// cases ordered by measured statement frequency; the commonest statements
+		// (expressions, returns) intentionally match nothing here
 		switch (statement.type) {
-			case "BlockStatement":
-				this.preWalkBlockStatement(statement);
-				break;
-			case "DoWhileStatement":
-				this.preWalkDoWhileStatement(statement);
-				break;
-			case "ForInStatement":
-				this.preWalkForInStatement(statement);
+			case "VariableDeclaration":
+				this.preWalkVariableDeclaration(statement);
 				break;
-			case "ForOfStatement":
-				this.preWalkForOfStatement(statement);
+			case "IfStatement":
+				this.preWalkIfStatement(statement);
 				break;
-			case "ForStatement":
-				this.preWalkForStatement(statement);
+			case "BlockStatement":
+				this.preWalkBlockStatement(statement);
 				break;
 			case "FunctionDeclaration":
 				this.preWalkFunctionDeclaration(statement);
 				break;
-			case "IfStatement":
-				this.preWalkIfStatement(statement);
-				break;
-			case "LabeledStatement":
-				this.preWalkLabeledStatement(statement);
-				break;
-			case "SwitchStatement":
-				this.preWalkSwitchStatement(statement);
+			case "ForStatement":
+				this.preWalkForStatement(statement);
 				break;
 			case "TryStatement":
 				this.preWalkTryStatement(statement);
 				break;
-			case "VariableDeclaration":
-				this.preWalkVariableDeclaration(statement);
+			case "SwitchStatement":
+				this.preWalkSwitchStatement(statement);
 				break;
 			case "WhileStatement":
 				this.preWalkWhileStatement(statement);
 				break;
+			case "ForInStatement":
+				this.preWalkForInStatement(statement);
+				break;
+			case "ForOfStatement":
+				this.preWalkForOfStatement(statement);
+				break;
+			case "DoWhileStatement":
+				this.preWalkDoWhileStatement(statement);
+				break;
+			case "LabeledStatement":
+				this.preWalkLabeledStatement(statement);
+				break;
 			case "WithStatement":
 				this.preWalkWithStatement(statement);
 				break;
@@ -2166,32 +2316,43 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Block pre walk statement.
 	 * @param {Statement | ModuleDeclaration | MaybeNamedClassDeclaration | MaybeNamedFunctionDeclaration} statement statement
 	 */
 	blockPreWalkStatement(statement) {
 		/** @type {StatementPath} */
 		(this.statementPath).push(statement);
-		if (this.hooks.blockPreStatement.call(statement)) {
+		const { blockPreStatement, blockPreStatementByType } = this.hooks;
+		let bail =
+			blockPreStatement.taps.length !== 0
+				? blockPreStatement.call(statement)
+				: undefined;
+		if (!bail) {
+			const typed = blockPreStatementByType.get(statement.type);
+			if (typed !== undefined) bail = typed.call(statement);
+		}
+		if (bail) {
 			this.prevStatement =
 				/** @type {StatementPath} */
 				(this.statementPath).pop();
 			return;
 		}
+		// cases ordered by measured statement frequency
 		switch (statement.type) {
-			case "ExportDefaultDeclaration":
-				this.blockPreWalkExportDefaultDeclaration(statement);
-				break;
-			case "ExportNamedDeclaration":
-				this.blockPreWalkExportNamedDeclaration(statement);
-				break;
 			case "VariableDeclaration":
 				this.blockPreWalkVariableDeclaration(statement);
 				break;
+			case "ExpressionStatement":
+				this.blockPreWalkExpressionStatement(statement);
+				break;
 			case "ClassDeclaration":
 				this.blockPreWalkClassDeclaration(statement);
 				break;
-			case "ExpressionStatement":
-				this.blockPreWalkExpressionStatement(statement);
+			case "ExportNamedDeclaration":
+				this.blockPreWalkExportNamedDeclaration(statement);
+				break;
+			case "ExportDefaultDeclaration":
+				this.blockPreWalkExportDefaultDeclaration(statement);
 		}
 		this.prevStatement =
 			/** @type {StatementPath} */
@@ -2199,56 +2360,48 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Processes the provided statement.
 	 * @param {Statement | ModuleDeclaration | MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration} statement statement
 	 */
 	walkStatement(statement) {
 		/** @type {StatementPath} */
 		(this.statementPath).push(statement);
-		if (this.hooks.statement.call(statement) !== undefined) {
+		const { statement: statementHook } = this.hooks;
+		if (
+			statementHook.taps.length !== 0 &&
+			statementHook.call(statement) !== undefined
+		) {
 			this.prevStatement =
 				/** @type {StatementPath} */
 				(this.statementPath).pop();
 			return;
 		}
+		// cases ordered by measured statement frequency; V8 compiles this to
+		// sequential compares, so hot types must come first
 		switch (statement.type) {
-			case "BlockStatement":
-				this.walkBlockStatement(statement);
-				break;
-			case "ClassDeclaration":
-				this.walkClassDeclaration(statement);
-				break;
-			case "DoWhileStatement":
-				this.walkDoWhileStatement(statement);
-				break;
-			case "ExportDefaultDeclaration":
-				this.walkExportDefaultDeclaration(statement);
-				break;
-			case "ExportNamedDeclaration":
-				this.walkExportNamedDeclaration(statement);
-				break;
 			case "ExpressionStatement":
 				this.walkExpressionStatement(statement);
 				break;
-			case "ForInStatement":
-				this.walkForInStatement(statement);
+			case "VariableDeclaration":
+				this.walkVariableDeclaration(statement);
 				break;
-			case "ForOfStatement":
-				this.walkForOfStatement(statement);
+			case "ReturnStatement":
+				this.walkReturnStatement(statement);
 				break;
-			case "ForStatement":
-				this.walkForStatement(statement);
+			case "IfStatement":
+				this.walkIfStatement(statement);
+				break;
+			case "BlockStatement":
+				this.walkBlockStatement(statement);
 				break;
 			case "FunctionDeclaration":
 				this.walkFunctionDeclaration(statement);
 				break;
-			case "IfStatement":
-				this.walkIfStatement(statement);
-				break;
-			case "LabeledStatement":
-				this.walkLabeledStatement(statement);
+			case "ForStatement":
+				this.walkForStatement(statement);
 				break;
-			case "ReturnStatement":
-				this.walkReturnStatement(statement);
+			case "TryStatement":
+				this.walkTryStatement(statement);
 				break;
 			case "SwitchStatement":
 				this.walkSwitchStatement(statement);
@@ -2256,15 +2409,30 @@ class JavascriptParser extends Parser {
 			case "ThrowStatement":
 				this.walkThrowStatement(statement);
 				break;
-			case "TryStatement":
-				this.walkTryStatement(statement);
-				break;
-			case "VariableDeclaration":
-				this.walkVariableDeclaration(statement);
-				break;
 			case "WhileStatement":
 				this.walkWhileStatement(statement);
 				break;
+			case "ClassDeclaration":
+				this.walkClassDeclaration(statement);
+				break;
+			case "ForInStatement":
+				this.walkForInStatement(statement);
+				break;
+			case "ForOfStatement":
+				this.walkForOfStatement(statement);
+				break;
+			case "DoWhileStatement":
+				this.walkDoWhileStatement(statement);
+				break;
+			case "ExportNamedDeclaration":
+				this.walkExportNamedDeclaration(statement);
+				break;
+			case "ExportDefaultDeclaration":
+				this.walkExportDefaultDeclaration(statement);
+				break;
+			case "LabeledStatement":
+				this.walkLabeledStatement(statement);
+				break;
 			case "WithStatement":
 				this.walkWithStatement(statement);
 				break;
@@ -2287,6 +2455,7 @@ class JavascriptParser extends Parser {
 
 	// Real Statements
 	/**
+	 * Pre walk block statement.
 	 * @param {BlockStatement} statement block statement
 	 */
 	preWalkBlockStatement(statement) {
@@ -2294,6 +2463,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Walk block statement.
 	 * @param {BlockStatement | StaticBlock} statement block statement
 	 */
 	walkBlockStatement(statement) {
@@ -2307,6 +2477,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Walk expression statement.
 	 * @param {ExpressionStatement} statement expression statement
 	 */
 	walkExpressionStatement(statement) {
@@ -2314,6 +2485,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Pre walk if statement.
 	 * @param {IfStatement} statement if statement
 	 */
 	preWalkIfStatement(statement) {
@@ -2324,27 +2496,47 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Walks a conditional branch with its guard frame (if any) pushed onto the
+	 * parser-state guard stack for the duration of the branch body.
+	 * @param {EXPECTED_OBJECT | undefined | null} frame guard frame, or falsy when the branch is unguarded
+	 * @param {() => void} walk branch walk
+	 * @returns {void}
+	 */
+	walkGuardedBranch(frame, walk) {
+		if (!frame) {
+			walk();
+			return;
+		}
+		const stack = this.state.guardStack || (this.state.guardStack = []);
+		stack.push(frame);
+		try {
+			walk();
+		} finally {
+			stack.pop();
+		}
+	}
+
+	/**
+	 * Processes the provided statement.
 	 * @param {IfStatement} statement if statement
 	 */
 	walkIfStatement(statement) {
 		const result = this.hooks.statementIf.call(statement);
 		if (result === undefined) {
-			const inGuard = this.hooks.collectGuards.call(statement.test);
-			if (inGuard) {
-				inGuard(() => {
-					this.walkExpression(statement.test);
-					this.walkNestedStatement(statement.consequent);
-				});
-			} else {
-				this.walkExpression(statement.test);
-				this.walkNestedStatement(statement.consequent);
-			}
+			const guard = this.hooks.collectGuards.call(statement.test);
+			this.walkExpression(statement.test);
+			this.walkGuardedBranch(guard ? guard.consequent : undefined, () =>
+				this.walkNestedStatement(statement.consequent)
+			);
 
 			const consequentTerminated = this.scope.terminated;
 			this.scope.terminated = undefined;
 
 			if (statement.alternate) {
-				this.walkNestedStatement(statement.alternate);
+				const alternate = statement.alternate;
+				this.walkGuardedBranch(guard ? guard.alternate : undefined, () =>
+					this.walkNestedStatement(alternate)
+				);
 			}
 
 			const alternateTerminated = this.scope.terminated;
@@ -2361,6 +2553,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Pre walk labeled statement.
 	 * @param {LabeledStatement} statement with statement
 	 */
 	preWalkLabeledStatement(statement) {
@@ -2368,6 +2561,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Walk labeled statement.
 	 * @param {LabeledStatement} statement with statement
 	 */
 	walkLabeledStatement(statement) {
@@ -2382,6 +2576,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Pre walk with statement.
 	 * @param {WithStatement} statement with statement
 	 */
 	preWalkWithStatement(statement) {
@@ -2389,9 +2584,16 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Walk with statement.
 	 * @param {WithStatement} statement with statement
 	 */
 	walkWithStatement(statement) {
+		if (this._strictInModuleOutput) {
+			this._reportStrictModeViolation(
+				"`with` statements are not allowed",
+				statement
+			);
+		}
 		this.inBlockScope(() => {
 			this.walkExpression(statement.object);
 			this.walkNestedStatement(statement.body);
@@ -2399,6 +2601,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Pre walk switch statement.
 	 * @param {SwitchStatement} statement switch statement
 	 */
 	preWalkSwitchStatement(statement) {
@@ -2406,6 +2609,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Walk switch statement.
 	 * @param {SwitchStatement} statement switch statement
 	 */
 	walkSwitchStatement(statement) {
@@ -2414,6 +2618,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Walk terminating statement.
 	 * @param {ReturnStatement | ThrowStatement} statement return or throw statement
 	 */
 	walkTerminatingStatement(statement) {
@@ -2429,6 +2634,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Walk return statement.
 	 * @param {ReturnStatement} statement return statement
 	 */
 	walkReturnStatement(statement) {
@@ -2436,6 +2642,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Walk throw statement.
 	 * @param {ThrowStatement} statement return statement
 	 */
 	walkThrowStatement(statement) {
@@ -2443,6 +2650,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Pre walk try statement.
 	 * @param {TryStatement} statement try statement
 	 */
 	preWalkTryStatement(statement) {
@@ -2452,6 +2660,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Walk try statement.
 	 * @param {TryStatement} statement try statement
 	 */
 	walkTryStatement(statement) {
@@ -2489,6 +2698,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Pre walk while statement.
 	 * @param {WhileStatement} statement while statement
 	 */
 	preWalkWhileStatement(statement) {
@@ -2496,6 +2706,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Walk while statement.
 	 * @param {WhileStatement} statement while statement
 	 */
 	walkWhileStatement(statement) {
@@ -2506,6 +2717,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Pre walk do while statement.
 	 * @param {DoWhileStatement} statement do while statement
 	 */
 	preWalkDoWhileStatement(statement) {
@@ -2513,6 +2725,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Walk do while statement.
 	 * @param {DoWhileStatement} statement do while statement
 	 */
 	walkDoWhileStatement(statement) {
@@ -2523,6 +2736,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Pre walk for statement.
 	 * @param {ForStatement} statement for statement
 	 */
 	preWalkForStatement(statement) {
@@ -2533,6 +2747,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Walk for statement.
 	 * @param {ForStatement} statement for statement
 	 */
 	walkForStatement(statement) {
@@ -2568,6 +2783,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Pre walk for in statement.
 	 * @param {ForInStatement} statement for statement
 	 */
 	preWalkForInStatement(statement) {
@@ -2578,6 +2794,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Walk for in statement.
 	 * @param {ForInStatement} statement for statement
 	 */
 	walkForInStatement(statement) {
@@ -2606,6 +2823,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Pre walk for of statement.
 	 * @param {ForOfStatement} statement statement
 	 */
 	preWalkForOfStatement(statement) {
@@ -2619,6 +2837,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Walk for of statement.
 	 * @param {ForOfStatement} statement for statement
 	 */
 	walkForOfStatement(statement) {
@@ -2647,6 +2866,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Pre walk function declaration.
 	 * @param {FunctionDeclaration | MaybeNamedFunctionDeclaration} statement function declaration
 	 */
 	preWalkFunctionDeclaration(statement) {
@@ -2656,11 +2876,15 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Walk function declaration.
 	 * @param {FunctionDeclaration | MaybeNamedFunctionDeclaration} statement function declaration
 	 */
 	walkFunctionDeclaration(statement) {
 		const wasTopLevel = this.scope.topLevelScope;
 		this.scope.topLevelScope = false;
+		if (this._strictInModuleOutput) {
+			this._checkStrictModeParams(statement.params);
+		}
 		this.inFunctionScope(true, statement.params, () => {
 			for (const param of statement.params) {
 				this.walkPattern(param);
@@ -2678,6 +2902,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Block pre walk expression statement.
 	 * @param {ExpressionStatement} statement expression statement
 	 */
 	blockPreWalkExpressionStatement(statement) {
@@ -2689,6 +2914,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Pre walk assignment expression.
 	 * @param {AssignmentExpression} expression assignment expression
 	 */
 	preWalkAssignmentExpression(expression) {
@@ -2696,6 +2922,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Enter destructuring assignment.
 	 * @param {Pattern} pattern pattern
 	 * @param {Expression} expression assignment expression
 	 * @returns {Expression | undefined} destructuring expression
@@ -2737,6 +2964,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Module pre walk import declaration.
 	 * @param {ImportDeclaration} statement statement
 	 */
 	modulePreWalkImportDeclaration(statement) {
@@ -2782,6 +3010,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Processes the provided declaration.
 	 * @param {Declaration} declaration declaration
 	 * @param {OnIdent} onIdent on ident callback
 	 */
@@ -2807,6 +3036,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Module pre walk export named declaration.
 	 * @param {ExportNamedDeclaration} statement statement
 	 */
 	modulePreWalkExportNamedDeclaration(statement) {
@@ -2847,6 +3077,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Block pre walk export named declaration.
 	 * @param {ExportNamedDeclaration} statement statement
 	 */
 	blockPreWalkExportNamedDeclaration(statement) {
@@ -2898,6 +3129,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Walk export named declaration.
 	 * @param {ExportNamedDeclaration} statement the statement
 	 */
 	walkExportNamedDeclaration(statement) {
@@ -2907,6 +3139,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Block pre walk export default declaration.
 	 * @param {ExportDefaultDeclaration} statement statement
 	 */
 	blockPreWalkExportDefaultDeclaration(statement) {
@@ -2942,6 +3175,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Walk export default declaration.
 	 * @param {ExportDefaultDeclaration} statement statement
 	 */
 	walkExportDefaultDeclaration(statement) {
@@ -2976,6 +3210,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Module pre walk export all declaration.
 	 * @param {ExportAllDeclaration} statement statement
 	 */
 	modulePreWalkExportAllDeclaration(statement) {
@@ -2991,6 +3226,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Pre walk variable declaration.
 	 * @param {VariableDeclaration} statement variable declaration
 	 */
 	preWalkVariableDeclaration(statement) {
@@ -2999,6 +3235,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Block pre walk variable declaration.
 	 * @param {VariableDeclaration} statement variable declaration
 	 */
 	blockPreWalkVariableDeclaration(statement) {
@@ -3014,32 +3251,53 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Pre walk variable declaration.
 	 * @param {VariableDeclaration} statement variable declaration
 	 * @param {HookMap<SyncBailHook<[Identifier], boolean | void>>} hookMap map of hooks
 	 */
 	_preWalkVariableDeclaration(statement, hookMap) {
+		/** @type {OnIdent | undefined} */
+		let onIdent;
 		for (const declarator of statement.declarations) {
-			switch (declarator.type) {
-				case "VariableDeclarator": {
-					this.preWalkVariableDeclarator(declarator);
-					if (!this.hooks.preDeclarator.call(declarator, statement)) {
-						this.enterPattern(declarator.id, (name, ident) => {
-							let hook = hookMap.get(name);
-							if (hook === undefined || !hook.call(ident)) {
-								hook = this.hooks.varDeclaration.get(name);
-								if (hook === undefined || !hook.call(ident)) {
-									this.defineVariable(name);
-								}
-							}
-						});
-					}
-					break;
+			if (declarator.type !== "VariableDeclarator") continue;
+			this.preWalkVariableDeclarator(declarator);
+			if (this.hooks.preDeclarator.call(declarator, statement)) continue;
+			const id = declarator.id;
+			if (id.type === "Identifier") {
+				// fast path: plain `const x =` skips the enterPattern dispatch and
+				// the per-declaration onIdent closure (only patterns need it)
+				if (!this.callHooksForName(this.hooks.pattern, id.name, id)) {
+					this._defineVariableForDeclaration(id.name, id, hookMap);
+				}
+			} else {
+				if (onIdent === undefined) {
+					onIdent = (name, ident) =>
+						this._defineVariableForDeclaration(name, ident, hookMap);
 				}
+				this.enterPattern(id, onIdent);
+			}
+		}
+	}
+
+	/**
+	 * Defines a declared variable unless a declaration hook handles it.
+	 * @param {string} name variable name
+	 * @param {Identifier} ident identifier node
+	 * @param {HookMap<SyncBailHook<[Identifier], boolean | void>>} hookMap kind-specific declaration hooks
+	 * @returns {void}
+	 */
+	_defineVariableForDeclaration(name, ident, hookMap) {
+		let hook = hookMap.get(name);
+		if (hook === undefined || !hook.call(ident)) {
+			hook = this.hooks.varDeclaration.get(name);
+			if (hook === undefined || !hook.call(ident)) {
+				this.defineVariable(name);
 			}
 		}
 	}
 
 	/**
+	 * Pre walk object pattern.
 	 * @param {ObjectPattern} objectPattern object pattern
 	 * @returns {DestructuringAssignmentProperties | undefined} set of names or undefined if not all keys are identifiers
 	 */
@@ -3071,7 +3329,6 @@ class JavascriptParser extends Parser {
 				props.add({
 					id: key.name,
 					range: /** @type {Range} */ (key.range),
-					loc: /** @type {SourceLocation} */ (key.loc),
 					pattern,
 					shorthand: this.scope.inShorthand
 				});
@@ -3088,7 +3345,6 @@ class JavascriptParser extends Parser {
 					props.add({
 						id: str,
 						range: /** @type {Range} */ (key.range),
-						loc: /** @type {SourceLocation} */ (key.loc),
 						pattern,
 						shorthand: this.scope.inShorthand
 					});
@@ -3104,6 +3360,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Pre walk array pattern.
 	 * @param {ArrayPattern} arrayPattern array pattern
 	 * @returns {Set<DestructuringAssignmentProperty> | undefined} set of names or undefined if not all keys are identifiers
 	 */
@@ -3124,7 +3381,6 @@ class JavascriptParser extends Parser {
 			props.add({
 				id: `${i}`,
 				range: /** @type {Range} */ (element.range),
-				loc: /** @type {SourceLocation} */ (element.loc),
 				pattern,
 				shorthand: false
 			});
@@ -3134,6 +3390,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Pre walk variable declarator.
 	 * @param {VariableDeclarator} declarator variable declarator
 	 */
 	preWalkVariableDeclarator(declarator) {
@@ -3143,6 +3400,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Walk variable declaration.
 	 * @param {VariableDeclaration} statement variable declaration
 	 */
 	walkVariableDeclaration(statement) {
@@ -3179,6 +3437,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Block pre walk class declaration.
 	 * @param {ClassDeclaration | MaybeNamedClassDeclaration} statement class declaration
 	 */
 	blockPreWalkClassDeclaration(statement) {
@@ -3188,6 +3447,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Walk class declaration.
 	 * @param {ClassDeclaration | MaybeNamedClassDeclaration} statement class declaration
 	 */
 	walkClassDeclaration(statement) {
@@ -3195,6 +3455,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Pre walk switch cases.
 	 * @param {SwitchCase[]} switchCases switch statement
 	 */
 	preWalkSwitchCases(switchCases) {
@@ -3205,6 +3466,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Processes the provided switch case.
 	 * @param {SwitchCase[]} switchCases switch statement
 	 */
 	walkSwitchCases(switchCases) {
@@ -3245,6 +3507,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Pre walk catch clause.
 	 * @param {CatchClause} catchClause catch clause
 	 */
 	preWalkCatchClause(catchClause) {
@@ -3252,6 +3515,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Processes the provided catch clause.
 	 * @param {CatchClause} catchClause catch clause
 	 */
 	walkCatchClause(catchClause) {
@@ -3271,11 +3535,18 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Processes the provided pattern.
 	 * @param {Pattern} pattern pattern
 	 */
 	walkPattern(pattern) {
 		switch (pattern.type) {
-			case "ArrayPattern":
+			// plain identifier bindings are the common case and walk nothing
+			case "Identifier":
+				break;
+			case "ObjectPattern":
+				this.walkObjectPattern(pattern);
+				break;
+			case "ArrayPattern":
 				this.walkArrayPattern(pattern);
 				break;
 			case "AssignmentPattern":
@@ -3284,9 +3555,6 @@ class JavascriptParser extends Parser {
 			case "MemberExpression":
 				this.walkMemberExpression(pattern);
 				break;
-			case "ObjectPattern":
-				this.walkObjectPattern(pattern);
-				break;
 			case "RestElement":
 				this.walkRestElement(pattern);
 				break;
@@ -3294,6 +3562,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Walk assignment pattern.
 	 * @param {AssignmentPattern} pattern assignment pattern
 	 */
 	walkAssignmentPattern(pattern) {
@@ -3302,6 +3571,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Walk object pattern.
 	 * @param {ObjectPattern} pattern pattern
 	 */
 	walkObjectPattern(pattern) {
@@ -3318,6 +3588,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Walk array pattern.
 	 * @param {ArrayPattern} pattern array pattern
 	 */
 	walkArrayPattern(pattern) {
@@ -3328,6 +3599,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Processes the provided pattern.
 	 * @param {RestElement} pattern rest element
 	 */
 	walkRestElement(pattern) {
@@ -3335,10 +3607,12 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Processes the provided expression.
 	 * @param {(Expression | SpreadElement | null)[]} expressions expressions
 	 */
 	walkExpressions(expressions) {
-		for (const expression of expressions) {
+		for (let i = 0, len = expressions.length; i < len; i++) {
+			const expression = expressions[i];
 			if (expression) {
 				this.walkExpression(expression);
 			}
@@ -3346,81 +3620,90 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Processes the provided expression.
 	 * @param {Expression | SpreadElement | PrivateIdentifier | Super} expression expression
 	 */
 	walkExpression(expression) {
+		// cases ordered by measured node frequency (identifiers are ~40% of all
+		// expressions) — V8 compiles this to sequential compares, so hot types
+		// must come first
 		switch (expression.type) {
-			case "ArrayExpression":
-				this.walkArrayExpression(expression);
+			case "Identifier":
+				this.walkIdentifier(expression);
 				break;
-			case "ArrowFunctionExpression":
-				this.walkArrowFunctionExpression(expression);
+			case "MemberExpression":
+				this.walkMemberExpression(expression);
 				break;
-			case "AssignmentExpression":
-				this.walkAssignmentExpression(expression);
+			case "Literal":
+				if (this._strictInModuleOutput) {
+					this._checkStrictModeLiteral(expression);
+				}
 				break;
-			case "AwaitExpression":
-				this.walkAwaitExpression(expression);
+			case "CallExpression":
+				this.walkCallExpression(expression);
 				break;
 			case "BinaryExpression":
 				this.walkBinaryExpression(expression);
 				break;
-			case "CallExpression":
-				this.walkCallExpression(expression);
-				break;
-			case "ChainExpression":
-				this.walkChainExpression(expression);
+			case "AssignmentExpression":
+				this.walkAssignmentExpression(expression);
 				break;
-			case "ClassExpression":
-				this.walkClassExpression(expression);
+			case "UnaryExpression":
+				this.walkUnaryExpression(expression);
 				break;
-			case "ConditionalExpression":
-				this.walkConditionalExpression(expression);
+			case "LogicalExpression":
+				this.walkLogicalExpression(expression);
 				break;
-			case "FunctionExpression":
-				this.walkFunctionExpression(expression);
+			case "ArrowFunctionExpression":
+				this.walkArrowFunctionExpression(expression);
 				break;
-			case "Identifier":
-				this.walkIdentifier(expression);
+			case "ThisExpression":
+				this.walkThisExpression(expression);
 				break;
-			case "ImportExpression":
-				this.walkImportExpression(expression);
+			case "ConditionalExpression":
+				this.walkConditionalExpression(expression);
 				break;
-			case "LogicalExpression":
-				this.walkLogicalExpression(expression);
+			case "ArrayExpression":
+				this.walkArrayExpression(expression);
 				break;
-			case "MetaProperty":
-				this.walkMetaProperty(expression);
+			case "ObjectExpression":
+				this.walkObjectExpression(expression);
 				break;
-			case "MemberExpression":
-				this.walkMemberExpression(expression);
+			case "FunctionExpression":
+				this.walkFunctionExpression(expression);
 				break;
 			case "NewExpression":
 				this.walkNewExpression(expression);
 				break;
-			case "ObjectExpression":
-				this.walkObjectExpression(expression);
+			case "TemplateLiteral":
+				this.walkTemplateLiteral(expression);
+				break;
+			case "SpreadElement":
+				this.walkSpreadElement(expression);
 				break;
 			case "SequenceExpression":
 				this.walkSequenceExpression(expression);
 				break;
-			case "SpreadElement":
-				this.walkSpreadElement(expression);
+			case "UpdateExpression":
+				this.walkUpdateExpression(expression);
 				break;
-			case "TaggedTemplateExpression":
-				this.walkTaggedTemplateExpression(expression);
+			case "AwaitExpression":
+				this.walkAwaitExpression(expression);
 				break;
-			case "TemplateLiteral":
-				this.walkTemplateLiteral(expression);
+			case "ChainExpression":
+				this.walkChainExpression(expression);
 				break;
-			case "ThisExpression":
-				this.walkThisExpression(expression);
+			case "ClassExpression":
+				this.walkClassExpression(expression);
 				break;
-			case "UnaryExpression":
-				this.walkUnaryExpression(expression);
+			case "ImportExpression":
+				this.walkImportExpression(expression);
 				break;
-			case "UpdateExpression":
-				this.walkUpdateExpression(expression);
+			case "MetaProperty":
+				this.walkMetaProperty(expression);
+				break;
+			case "TaggedTemplateExpression":
+				this.walkTaggedTemplateExpression(expression);
 				break;
 			case "YieldExpression":
 				this.walkYieldExpression(expression);
@@ -3429,6 +3712,36 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Reports octal number literals (`0777`) and octal string escapes (`"\47"`),
+	 * both SyntaxErrors in strict-mode ESM output.
+	 * @param {Literal} expression literal
+	 */
+	_checkStrictModeLiteral(expression) {
+		const raw = /** @type {string | undefined} */ (expression.raw);
+		if (raw === undefined) return;
+		if (typeof expression.value === "number") {
+			// Legacy octal (`0777`) or non-octal decimal (`08`) integer literal.
+			if (
+				raw.length > 1 &&
+				raw.charCodeAt(0) === 48 &&
+				raw.charCodeAt(1) >= 48 &&
+				raw.charCodeAt(1) <= 57
+			) {
+				this._reportStrictModeViolation(
+					"Octal literals are not allowed",
+					expression
+				);
+			}
+		} else if (typeof expression.value === "string" && hasOctalEscape(raw)) {
+			this._reportStrictModeViolation(
+				"Octal escape sequences are not allowed",
+				expression
+			);
+		}
+	}
+
+	/**
+	 * Walk await expression.
 	 * @param {AwaitExpression} expression await expression
 	 */
 	walkAwaitExpression(expression) {
@@ -3439,6 +3752,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Walk array expression.
 	 * @param {ArrayExpression} expression array expression
 	 */
 	walkArrayExpression(expression) {
@@ -3448,6 +3762,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Walk spread element.
 	 * @param {SpreadElement} expression spread element
 	 */
 	walkSpreadElement(expression) {
@@ -3457,6 +3772,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Walk object expression.
 	 * @param {ObjectExpression} expression object expression
 	 */
 	walkObjectExpression(expression) {
@@ -3471,6 +3787,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Processes the provided prop.
 	 * @param {Property | SpreadElement} prop property or spread element
 	 */
 	walkProperty(prop) {
@@ -3494,18 +3811,21 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Walk function expression.
 	 * @param {FunctionExpression} expression arrow function expression
 	 */
 	walkFunctionExpression(expression) {
 		const wasTopLevel = this.scope.topLevelScope;
 		this.scope.topLevelScope = false;
-		const scopeParams = [...expression.params];
-
-		// Add function name in scope for recursive calls
-		if (expression.id) {
-			scopeParams.push(expression.id);
+		// Only copy params when the function name must be added (recursive calls);
+		// inFunctionScope reads params without mutating, like arrow functions.
+		const scopeParams = expression.id
+			? [...expression.params, expression.id]
+			: expression.params;
+
+		if (this._strictInModuleOutput) {
+			this._checkStrictModeParams(expression.params);
 		}
-
 		this.inFunctionScope(true, scopeParams, () => {
 			for (const param of expression.params) {
 				this.walkPattern(param);
@@ -3523,11 +3843,15 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Walk arrow function expression.
 	 * @param {ArrowFunctionExpression} expression arrow function expression
 	 */
 	walkArrowFunctionExpression(expression) {
 		const wasTopLevel = this.scope.topLevelScope;
 		this.scope.topLevelScope = wasTopLevel ? "arrow" : false;
+		if (this._strictInModuleOutput) {
+			this._checkStrictModeParams(expression.params);
+		}
 		this.inFunctionScope(false, expression.params, () => {
 			for (const param of expression.params) {
 				this.walkPattern(param);
@@ -3546,6 +3870,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Walk sequence expression.
 	 * @param {SequenceExpression} expression the sequence
 	 */
 	walkSequenceExpression(expression) {
@@ -3584,13 +3909,90 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Walk update expression.
 	 * @param {UpdateExpression} expression the update expression
 	 */
 	walkUpdateExpression(expression) {
+		if (
+			this._strictInModuleOutput &&
+			expression.argument.type === "Identifier"
+		) {
+			this._checkStrictModeAssignTarget(expression.argument.name, expression);
+		}
 		this.walkExpression(expression.argument);
 	}
 
 	/**
+	 * Reports `arguments.callee` / `arguments.caller` — both throw a TypeError
+	 * once the module runs in strict-mode ESM output.
+	 * @param {string} name accessed member name
+	 * @param {Expression} node node to report the violation at
+	 */
+	_checkStrictModeArgumentsMember(name, node) {
+		if ((name === "callee" || name === "caller") && !this.scope.isStrict) {
+			this._reportStrictModeViolation(
+				`Accessing "arguments.${name}" is not allowed`,
+				node
+			);
+		}
+	}
+
+	/**
+	 * Reports an assignment or update target that breaks in strict-mode ESM
+	 * output: `eval` / `arguments` are a SyntaxError, the read-only globals
+	 * (`undefined`, `NaN`, `Infinity`) a TypeError instead of a silent no-op.
+	 * @param {string} name target identifier name
+	 * @param {AssignmentExpression | UpdateExpression} node node to report the violation at
+	 */
+	_checkStrictModeAssignTarget(name, node) {
+		if (name === "eval" || name === "arguments") {
+			this._reportStrictModeViolation(
+				`Assigning to "${name}" is not allowed`,
+				node
+			);
+		} else if (
+			(name === "undefined" || name === "NaN" || name === "Infinity") &&
+			!this.scope.isStrict &&
+			!this.isVariableDefined(name)
+		) {
+			this._reportStrictModeViolation(
+				`Assigning to the read-only global "${name}" is not allowed`,
+				node
+			);
+		}
+	}
+
+	/**
+	 * Reports strict-mode-only errors in a function's parameter list: a duplicate
+	 * simple parameter, or a parameter named `eval` / `arguments`.
+	 * @param {(import("estree").Pattern)[]} params function parameters
+	 */
+	_checkStrictModeParams(params) {
+		/** @type {Set<string> | undefined} */
+		let seen;
+		for (const param of params) {
+			if (param.type !== "Identifier") continue;
+			const name = param.name;
+			if (name === "eval" || name === "arguments") {
+				this._reportStrictModeViolation(
+					`"${name}" is not allowed as a parameter name`,
+					param
+				);
+			}
+			if (seen === undefined) seen = new Set();
+			if (seen.has(name)) {
+				this._reportStrictModeViolation(
+					`Duplicate parameter name "${name}" is not allowed`,
+					param
+				);
+			} else {
+				seen.add(name);
+			}
+		}
+	}
+
+	/**
+	 * Walk unary expression.
 	 * @param {UnaryExpression} expression the unary expression
 	 */
 	walkUnaryExpression(expression) {
@@ -3609,11 +4011,41 @@ class JavascriptParser extends Parser {
 				);
 				if (result === true) return;
 			}
+		} else if (
+			this._strictInModuleOutput &&
+			expression.operator === "delete" &&
+			expression.argument.type === "Identifier"
+		) {
+			this._reportStrictModeViolation(
+				`Deleting the unqualified identifier "${expression.argument.name}" is not allowed`,
+				expression
+			);
 		}
 		this.walkExpression(expression.argument);
 	}
 
 	/**
+	 * Reports a construct that a loose script allows but that breaks once the
+	 * module is emitted as strict-mode ESM output. Severity comes from the
+	 * `strictModeViolations` parser option (`false` disables the checks upfront).
+	 * The location is computed here, on the rare violation path only.
+	 * @param {string} reason what is not allowed
+	 * @param {Statement | Expression | Identifier} node node to report the violation at
+	 */
+	_reportStrictModeViolation(reason, node) {
+		const diagnostic = new WebpackError(
+			`${reason}. The output is an ES module, which runs in strict mode.`
+		);
+		diagnostic.loc = this.getLocation(node);
+		if (this.options.strictModeViolations === "error") {
+			this.state.module.addError(diagnostic);
+		} else {
+			this.state.module.addWarning(diagnostic);
+		}
+	}
+
+	/**
+	 * Walk left right expression.
 	 * @param {LogicalExpression | BinaryExpression} expression the expression
 	 */
 	walkLeftRightExpression(expression) {
@@ -3622,6 +4054,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Walk binary expression.
 	 * @param {BinaryExpression} expression the binary expression
 	 */
 	walkBinaryExpression(expression) {
@@ -3631,6 +4064,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Walk logical expression.
 	 * @param {LogicalExpression} expression the logical expression
 	 */
 	walkLogicalExpression(expression) {
@@ -3643,10 +4077,14 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Walk assignment expression.
 	 * @param {AssignmentExpression} expression assignment expression
 	 */
 	walkAssignmentExpression(expression) {
 		if (expression.left.type === "Identifier") {
+			if (this._strictInModuleOutput) {
+				this._checkStrictModeAssignTarget(expression.left.name, expression);
+			}
 			const renameIdentifier = this.getRenameIdentifier(expression.right);
 			if (
 				renameIdentifier &&
@@ -3718,24 +4156,23 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Walk conditional expression.
 	 * @param {ConditionalExpression} expression conditional expression
 	 */
 	walkConditionalExpression(expression) {
 		const result = this.hooks.expressionConditionalOperator.call(expression);
 		if (result === undefined) {
-			const inGuard = this.hooks.collectGuards.call(expression.test);
-			if (inGuard) {
-				inGuard(() => {
-					this.walkExpression(expression.test);
-					this.walkExpression(expression.consequent);
-				});
-			} else {
-				this.walkExpression(expression.test);
-				this.walkExpression(expression.consequent);
-			}
+			const guard = this.hooks.collectGuards.call(expression.test);
+			this.walkExpression(expression.test);
+			this.walkGuardedBranch(guard ? guard.consequent : undefined, () =>
+				this.walkExpression(expression.consequent)
+			);
 
 			if (expression.alternate) {
-				this.walkExpression(expression.alternate);
+				const alternate = expression.alternate;
+				this.walkGuardedBranch(guard ? guard.alternate : undefined, () =>
+					this.walkExpression(alternate)
+				);
 			}
 		} else if (result) {
 			this.walkExpression(expression.consequent);
@@ -3745,6 +4182,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Walk new expression.
 	 * @param {NewExpression} expression new expression
 	 */
 	walkNewExpression(expression) {
@@ -3761,6 +4199,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Walk yield expression.
 	 * @param {YieldExpression} expression yield expression
 	 */
 	walkYieldExpression(expression) {
@@ -3770,6 +4209,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Walk template literal.
 	 * @param {TemplateLiteral} expression template literal
 	 */
 	walkTemplateLiteral(expression) {
@@ -3779,6 +4219,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Walk tagged template expression.
 	 * @param {TaggedTemplateExpression} expression tagged template expression
 	 */
 	walkTaggedTemplateExpression(expression) {
@@ -3793,6 +4234,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Walk class expression.
 	 * @param {ClassExpression} expression the class expression
 	 */
 	walkClassExpression(expression) {
@@ -3800,6 +4242,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Walk chain expression.
 	 * @param {ChainExpression} expression expression
 	 */
 	walkChainExpression(expression) {
@@ -3815,6 +4258,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Processes the provided function expression.
 	 * @private
 	 * @param {FunctionExpression | ArrowFunctionExpression} functionExpression function expression
 	 * @param {(Expression | SpreadElement)[]} options options
@@ -3822,6 +4266,7 @@ class JavascriptParser extends Parser {
 	 */
 	_walkIIFE(functionExpression, options, currentThis) {
 		/**
+		 * Returns var info.
 		 * @param {Expression | SpreadElement} argOrThis arg or this
 		 * @returns {string | VariableInfo | undefined} var info
 		 */
@@ -3890,6 +4335,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Walk import expression.
 	 * @param {ImportExpression} expression import expression
 	 */
 	walkImportExpression(expression) {
@@ -3900,18 +4346,13 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Walk call expression.
 	 * @param {CallExpression} expression expression
 	 */
 	walkCallExpression(expression) {
-		/**
-		 * @param {FunctionExpression | ArrowFunctionExpression} fn function
-		 * @returns {boolean} true when simple function
-		 */
-		const isSimpleFunction = (fn) =>
-			fn.params.every((p) => p.type === "Identifier");
 		if (
 			expression.callee.type === "MemberExpression" &&
-			expression.callee.object.type.endsWith("FunctionExpression") &&
+			isFunctionExpression(expression.callee.object.type) &&
 			!expression.callee.computed &&
 			/** @type {boolean} */
 			(
@@ -3934,7 +4375,7 @@ class JavascriptParser extends Parser {
 				expression.arguments[0]
 			);
 		} else if (
-			expression.callee.type.endsWith("FunctionExpression") &&
+			isFunctionExpression(expression.callee.type) &&
 			isSimpleFunction(
 				/** @type {FunctionExpression | ArrowFunctionExpression} */
 				(expression.callee)
@@ -3949,21 +4390,29 @@ class JavascriptParser extends Parser {
 			);
 		} else {
 			if (expression.callee.type === "MemberExpression") {
-				const exprInfo = this.getMemberExpressionInfo(
-					expression.callee,
-					ALLOWED_MEMBER_TYPES_CALL_EXPRESSION
-				);
-				if (exprInfo && exprInfo.type === "call") {
-					const result = this.callHooksForInfo(
-						this.hooks.callMemberChainOfCallMemberChain,
-						exprInfo.rootInfo,
-						expression,
-						exprInfo.getCalleeMembers(),
-						exprInfo.call,
-						exprInfo.getMembers(),
-						exprInfo.getMemberRanges()
+				// callMemberChainOfCallMemberChain only applies to call-rooted
+				// chains (e.g. `a().b()`); for the common identifier/this-rooted
+				// callee the CALL lookup always rejects, so gate on the cheap root.
+				if (
+					this.getMemberExpressionRoot(expression.callee).type ===
+					"CallExpression"
+				) {
+					const exprInfo = this.getMemberExpressionInfo(
+						expression.callee,
+						ALLOWED_MEMBER_TYPES_CALL_EXPRESSION
 					);
-					if (result === true) return;
+					if (exprInfo && exprInfo.type === "call") {
+						const result = this.callHooksForInfo(
+							this.hooks.callMemberChainOfCallMemberChain,
+							exprInfo.rootInfo,
+							expression,
+							exprInfo.getCalleeMembers(),
+							exprInfo.call,
+							exprInfo.getMembers(),
+							exprInfo.getMemberRanges()
+						);
+						if (result === true) return;
+					}
 				}
 				// import("./m").then(m => { ... })
 				if (
@@ -3978,19 +4427,33 @@ class JavascriptParser extends Parser {
 					if (result === true) return;
 				}
 			}
+			if (
+				expression.callee.type === "Identifier" &&
+				this._evalIdentOwnTaps &&
+				expression.callee.name !== "undefined" &&
+				this._isDefinedPlainVariable(expression.callee.name)
+			) {
+				// a defined, untagged callee can only evaluate to the fallthrough
+				// result, so no call hooks apply — walk callee and arguments
+				// directly, skipping the hook dispatch and its result object
+				this.walkExpression(expression.callee);
+				if (expression.arguments) this.walkExpressions(expression.arguments);
+				return;
+			}
 			const callee = this.evaluateExpression(expression.callee);
 			if (callee.isIdentifier()) {
+				const members =
+					/** @type {NonNullable<BasicEvaluatedExpression["getMembers"]>} */
+					(callee.getMembers)();
 				const result1 = this.callHooksForInfo(
 					this.hooks.callMemberChain,
 					/** @type {NonNullable<BasicEvaluatedExpression["rootInfo"]>} */
 					(callee.rootInfo),
 					expression,
-					/** @type {NonNullable<BasicEvaluatedExpression["getMembers"]>} */
-					(callee.getMembers)(),
+					members,
 					callee.getMembersOptionals
 						? callee.getMembersOptionals()
-						: /** @type {NonNullable<BasicEvaluatedExpression["getMembers"]>} */
-							(callee.getMembers)().map(() => false),
+						: members.map(RETURN_FALSE),
 					callee.getMemberRanges ? callee.getMemberRanges() : []
 				);
 				if (result1 === true) return;
@@ -4019,6 +4482,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Walk member expression.
 	 * @param {MemberExpression} expression member expression
 	 */
 	walkMemberExpression(expression) {
@@ -4085,6 +4549,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Walk member expression with expression name.
 	 * @template R
 	 * @param {MemberExpression} expression member expression
 	 * @param {string} name name
@@ -4102,10 +4567,10 @@ class JavascriptParser extends Parser {
 		if (expression.object.type === "MemberExpression") {
 			// optimize the case where expression.object is a MemberExpression too.
 			// we can keep info here when calling walkMemberExpression directly
-			const property =
-				/** @type {Identifier} */
-				(expression.property).name ||
-				`${/** @type {Literal} */ (expression.property).value}`;
+			// Read the property from `members` (already extracted by
+			// extractMemberExpressionChain) since the AST node may be a
+			// TemplateLiteral, which has neither .name nor .value.
+			const property = members[members.length - 1];
 			name = name.slice(0, -property.length - 1);
 			members.pop();
 			const result = this.callHooksForInfo(
@@ -4128,6 +4593,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Walk this expression.
 	 * @param {ThisExpression} expression this expression
 	 */
 	walkThisExpression(expression) {
@@ -4135,6 +4601,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Processes the provided expression.
 	 * @param {Identifier} expression identifier
 	 */
 	walkIdentifier(expression) {
@@ -4142,6 +4609,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Walk meta property.
 	 * @param {MetaProperty} metaProperty meta property
 	 */
 	walkMetaProperty(metaProperty) {
@@ -4149,6 +4617,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Call hooks for expression.
 	 * @template T
 	 * @template R
 	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks the should be called
@@ -4167,6 +4636,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Call hooks for expression with fallback.
 	 * @template T
 	 * @template R
 	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks the should be called
@@ -4201,6 +4671,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Call hooks for name.
 	 * @template T
 	 * @template R
 	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks the should be called
@@ -4209,16 +4680,17 @@ class JavascriptParser extends Parser {
 	 * @returns {R | undefined} result of hook
 	 */
 	callHooksForName(hookMap, name, ...args) {
-		return this.callHooksForNameWithFallback(
+		return this._callHooksForInfo(
 			hookMap,
-			name,
+			this.getVariableInfo(name),
 			undefined,
 			undefined,
-			...args
+			args
 		);
 	}
 
 	/**
+	 * Call hooks for info.
 	 * @template T
 	 * @template R
 	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks that should be called
@@ -4227,16 +4699,11 @@ class JavascriptParser extends Parser {
 	 * @returns {R | undefined} result of hook
 	 */
 	callHooksForInfo(hookMap, info, ...args) {
-		return this.callHooksForInfoWithFallback(
-			hookMap,
-			info,
-			undefined,
-			undefined,
-			...args
-		);
+		return this._callHooksForInfo(hookMap, info, undefined, undefined, args);
 	}
 
 	/**
+	 * Call hooks for info with fallback.
 	 * @template T
 	 * @template R
 	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks the should be called
@@ -4247,6 +4714,23 @@ class JavascriptParser extends Parser {
 	 * @returns {R | undefined} result of hook
 	 */
 	callHooksForInfoWithFallback(hookMap, info, fallback, defined, ...args) {
+		return this._callHooksForInfo(hookMap, info, fallback, defined, args);
+	}
+
+	/**
+	 * Shared core for the callHooksFor* helpers. Takes `args` as an already
+	 * collected array so the public wrappers each allocate it once instead of
+	 * re-collecting it through several rest-parameter layers (hot per identifier).
+	 * @template T
+	 * @template R
+	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks that should be called
+	 * @param {ExportedVariableInfo} info variable info
+	 * @param {((name: string) => R | undefined) | undefined} fallback callback when variable is 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
+	 */
+	_callHooksForInfo(hookMap, info, fallback, defined, args) {
 		/** @type {string} */
 		let name;
 		if (typeof info === "string") {
@@ -4288,6 +4772,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Call hooks for name with fallback.
 	 * @template T
 	 * @template R
 	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks the should be called
@@ -4298,16 +4783,17 @@ class JavascriptParser extends Parser {
 	 * @returns {R | undefined} result of hook
 	 */
 	callHooksForNameWithFallback(hookMap, name, fallback, defined, ...args) {
-		return this.callHooksForInfoWithFallback(
+		return this._callHooksForInfo(
 			hookMap,
 			this.getVariableInfo(name),
 			fallback,
 			defined,
-			...args
+			args
 		);
 	}
 
 	/**
+	 * Processes the provided param.
 	 * @deprecated
 	 * @param {(string | Pattern | Property)[]} params scope params
 	 * @param {() => void} fn inner function
@@ -4328,9 +4814,7 @@ class JavascriptParser extends Parser {
 
 		this.undefineVariable("this");
 
-		this.enterPatterns(params, (ident) => {
-			this.defineVariable(ident);
-		});
+		this.enterPatterns(params, this._defineVariable);
 
 		fn();
 
@@ -4338,6 +4822,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Processes the provided has thi.
 	 * @param {boolean} hasThis true, when this is defined
 	 * @param {Identifier[]} params scope params
 	 * @param {() => void} fn inner function
@@ -4360,9 +4845,7 @@ class JavascriptParser extends Parser {
 			this.undefineVariable("this");
 		}
 
-		this.enterPatterns(params, (ident) => {
-			this.defineVariable(ident);
-		});
+		this.enterPatterns(params, this._defineVariable);
 
 		fn();
 
@@ -4370,6 +4853,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Processes the provided has thi.
 	 * @param {boolean} hasThis true, when this is defined
 	 * @param {(Pattern | string)[]} params scope params
 	 * @param {() => void} fn inner function
@@ -4392,9 +4876,7 @@ class JavascriptParser extends Parser {
 			this.undefineVariable("this");
 		}
 
-		this.enterPatterns(params, (ident) => {
-			this.defineVariable(ident);
-		});
+		this.enterPatterns(params, this._defineVariable);
 
 		fn();
 
@@ -4402,6 +4884,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Processes the provided fn.
 	 * @param {() => void} fn inner function
 	 * @param {boolean} inExecutedPath executed state
 	 * @returns {void}
@@ -4431,37 +4914,34 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Processes the provided statement.
 	 * @param {(Directive | Statement | ModuleDeclaration)[]} statements statements
 	 */
 	detectMode(statements) {
-		const isLiteral =
-			statements.length >= 1 &&
-			statements[0].type === "ExpressionStatement" &&
-			statements[0].expression.type === "Literal";
+		const statement = statements.length >= 1 ? statements[0] : undefined;
 		if (
-			isLiteral &&
-			/** @type {Literal} */
-			(/** @type {ExpressionStatement} */ (statements[0]).expression).value ===
-				"use strict"
+			statement === undefined ||
+			statement.type !== "ExpressionStatement" ||
+			statement.expression.type !== "Literal"
 		) {
-			this.scope.isStrict = true;
+			return;
 		}
-		if (
-			isLiteral &&
-			/** @type {Literal} */
-			(/** @type {ExpressionStatement} */ (statements[0]).expression).value ===
-				"use asm"
-		) {
+		const value = /** @type {Literal} */ (statement.expression).value;
+		if (value === "use strict") {
+			this.scope.isStrict = true;
+		} else if (value === "use asm") {
 			this.scope.isAsmJs = true;
 		}
 	}
 
 	/**
+	 * Processes the provided pattern.
 	 * @param {(string | Pattern | Property)[]} patterns patterns
 	 * @param {OnIdentString} onIdent on ident callback
 	 */
 	enterPatterns(patterns, onIdent) {
-		for (const pattern of patterns) {
+		for (let i = 0, len = patterns.length; i < len; i++) {
+			const pattern = patterns[i];
 			if (typeof pattern !== "string") {
 				this.enterPattern(pattern, onIdent);
 			} else if (pattern) {
@@ -4471,27 +4951,20 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Processes the provided pattern.
 	 * @param {Pattern | Property} pattern pattern
 	 * @param {OnIdent} onIdent on ident callback
 	 */
 	enterPattern(pattern, onIdent) {
 		if (!pattern) return;
+		// plain identifiers dominate bindings, so match them first
 		switch (pattern.type) {
-			case "ArrayPattern":
-				this.enterArrayPattern(pattern, onIdent);
-				break;
-			case "AssignmentPattern":
-				this.enterAssignmentPattern(pattern, onIdent);
-				break;
 			case "Identifier":
 				this.enterIdentifier(pattern, onIdent);
 				break;
 			case "ObjectPattern":
 				this.enterObjectPattern(pattern, onIdent);
 				break;
-			case "RestElement":
-				this.enterRestElement(pattern, onIdent);
-				break;
 			case "Property":
 				if (pattern.shorthand && pattern.value.type === "Identifier") {
 					this.scope.inShorthand = pattern.value.name;
@@ -4501,10 +4974,20 @@ class JavascriptParser extends Parser {
 					this.enterPattern(/** @type {Pattern} */ (pattern.value), onIdent);
 				}
 				break;
+			case "ArrayPattern":
+				this.enterArrayPattern(pattern, onIdent);
+				break;
+			case "AssignmentPattern":
+				this.enterAssignmentPattern(pattern, onIdent);
+				break;
+			case "RestElement":
+				this.enterRestElement(pattern, onIdent);
+				break;
 		}
 	}
 
 	/**
+	 * Processes the provided pattern.
 	 * @param {Identifier} pattern identifier pattern
 	 * @param {OnIdent} onIdent callback
 	 */
@@ -4515,6 +4998,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Enter object pattern.
 	 * @param {ObjectPattern} pattern object pattern
 	 * @param {OnIdent} onIdent callback
 	 */
@@ -4530,6 +5014,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Enter array pattern.
 	 * @param {ArrayPattern} pattern object pattern
 	 * @param {OnIdent} onIdent callback
 	 */
@@ -4548,6 +5033,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Enter rest element.
 	 * @param {RestElement} pattern object pattern
 	 * @param {OnIdent} onIdent callback
 	 */
@@ -4556,6 +5042,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Enter assignment pattern.
 	 * @param {AssignmentPattern} pattern object pattern
 	 * @param {OnIdent} onIdent callback
 	 */
@@ -4564,6 +5051,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Evaluate expression.
 	 * @param {Expression | SpreadElement | PrivateIdentifier | Super} expression expression node
 	 * @returns {BasicEvaluatedExpression} evaluation result
 	 */
@@ -4582,12 +5070,13 @@ class JavascriptParser extends Parser {
 			console.warn(err);
 			// ignore error
 		}
-		return new BasicEvaluatedExpression()
-			.setRange(/** @type {Range} */ (expression.range))
-			.setExpression(expression);
+		// no setRange: the range is served lazily from the expression on first
+		// read, so plain results don't materialize the node's range array at all
+		return new BasicEvaluatedExpression().setExpression(expression);
 	}
 
 	/**
+	 * Returns parsed string.
 	 * @param {Expression} expression expression
 	 * @returns {string} parsed string
 	 */
@@ -4612,6 +5101,7 @@ class JavascriptParser extends Parser {
 	/** @typedef {{ range?: Range, value: string, code: boolean, conditional: false | CalculatedStringResult[] }} CalculatedStringResult */
 
 	/**
+	 * Parses calculated string.
 	 * @param {Expression} expression expression
 	 * @returns {CalculatedStringResult} result
 	 */
@@ -4701,6 +5191,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Parses the provided source and updates the parser state.
 	 * @param {string | Buffer | PreparsedAst} source the source to parse
 	 * @param {ParserState} state the parser state
 	 * @returns {ParserState} the parser state
@@ -4712,35 +5203,29 @@ class JavascriptParser extends Parser {
 
 		if (Buffer.isBuffer(source)) {
 			source = source.toString("utf8");
+			// Keep `state.source` as a string so downstream walkers can read
+			// the original text without re-decoding the Buffer on every use.
+			state.source = source;
 		}
 
 		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 {
-			({ ast, comments, semicolons } = JavascriptParser._parse(
+			({ ast, comments } = JavascriptParser._parse(
 				source,
 				{
 					sourceType: this.sourceType,
-					locations: true,
+					// line/column locations are derived from node offsets via
+					// getLocation — parsers never need to track them
+					locations: false,
 					ranges: true,
 					comments: true,
-					semicolons: true
+					importPhases: this.options.importPhases === true
 				},
 				this.options.parse
 			));
@@ -4752,6 +5237,18 @@ class JavascriptParser extends Parser {
 		const oldSemicolons = this.semicolons;
 		const oldStatementPath = this.statementPath;
 		const oldPrevStatement = this.prevStatement;
+		const oldStrictInModuleOutput = this._strictInModuleOutput;
+		const oldSource = this._source;
+		const oldLineStarts = this._lineStarts;
+		// a preparsed AST carries no text, but the build passes the module
+		// source in the state — offsets still map for it
+		this._source =
+			typeof source === "string"
+				? source
+				: typeof state.source === "string"
+					? state.source
+					: undefined;
+		this._lineStarts = undefined;
 		this.scope = {
 			topLevelScope: true,
 			inTry: false,
@@ -4764,13 +5261,34 @@ class JavascriptParser extends Parser {
 		};
 		this.state = state;
 		this.comments = comments;
-		this.semicolons = semicolons;
+		this.semicolons = undefined;
+		// evaluating a defined, untagged identifier can only fall through when
+		// every `evaluate.for("Identifier")` tap is the parser's own — plugins
+		// tapping or intercepting it disable the callee/rename fast paths
+		const identifierEvalHook = this.hooks.evaluate.get("Identifier");
+		this._evalIdentOwnTaps =
+			identifierEvalHook !== undefined &&
+			identifierEvalHook.interceptors.length === 0 &&
+			identifierEvalHook.taps.every((tap) => tap.name === CLASS_NAME);
 		this.statementPath = [];
 		this.prevStatement = undefined;
+		// The output is emitted as strict-mode ESM, but this module was parsed as
+		// a loose script — acorn skipped the strict early errors that will break
+		// the bundle at runtime. Enables the strict-mode diagnostics below.
+		this._strictInModuleOutput =
+			this.options.strictModeViolations !== false &&
+			state.compilation !== undefined &&
+			state.compilation.runtimeTemplate.isModule();
 		if (this.hooks.program.call(ast, comments) === undefined) {
 			this.destructuringAssignmentProperties = new WeakMap();
 			this.detectMode(ast.body);
+			// a strict program (ESM source, `"use strict"`) keeps its behavior in
+			// strict output — drop the flag so the walk pays no per-node checks
+			if (this._strictInModuleOutput && this.scope.isStrict) {
+				this._strictInModuleOutput = false;
+			}
 			this.modulePreWalkStatements(ast.body);
+			this.prevStatement = undefined;
 			this.preWalkStatements(ast.body);
 			this.prevStatement = undefined;
 			this.blockPreWalkStatements(ast.body);
@@ -4785,19 +5303,54 @@ class JavascriptParser extends Parser {
 		this.semicolons = oldSemicolons;
 		this.statementPath = oldStatementPath;
 		this.prevStatement = oldPrevStatement;
+		this._strictInModuleOutput = oldStrictInModuleOutput;
+		// release — these retain the whole source string and its line table
+		this._source = oldSource;
+		this._lineStarts = oldLineStarts;
 		return state;
 	}
 
 	/**
+	 * Returns evaluation result.
 	 * @param {string} source source code
 	 * @returns {BasicEvaluatedExpression} evaluation result
 	 */
 	evaluate(source) {
-		const { ast } = JavascriptParser._parse(
-			`(${source})`,
-			{ sourceType: this.sourceType },
-			this.options.parse
-		);
+		const importPhases = this.options.importPhases === true;
+		const compilation = this.state && this.state.compilation;
+		/** @type {Map<string, Program> | undefined} */
+		let cache;
+		// custom parse functions are not necessarily pure, do not cache for them
+		if (compilation !== undefined && typeof this.options.parse !== "function") {
+			cache = evaluateAstCaches.get(compilation);
+			if (cache === undefined) {
+				cache = new Map();
+				evaluateAstCaches.set(compilation, cache);
+			}
+		}
+		const cacheKey =
+			cache === undefined
+				? undefined
+				: `${this.sourceType}|${importPhases}|${source}`;
+		let ast =
+			cacheKey === undefined
+				? undefined
+				: /** @type {Map<string, Program>} */ (cache).get(cacheKey);
+		if (ast === undefined) {
+			({ ast } = JavascriptParser._parse(
+				`(${source})`,
+				{
+					sourceType: this.sourceType,
+					importPhases
+				},
+				this.options.parse
+			));
+			if (cacheKey !== undefined) {
+				const map = /** @type {Map<string, Program>} */ (cache);
+				if (map.size >= EVALUATE_AST_CACHE_LIMIT) map.clear();
+				map.set(cacheKey, ast);
+			}
+		}
 		if (ast.body.length !== 1 || ast.body[0].type !== "ExpressionStatement") {
 			throw new Error("evaluate: Source is not a expression");
 		}
@@ -4805,6 +5358,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Checks whether this javascript parser is pure.
 	 * @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
@@ -4816,7 +5370,6 @@ class JavascriptParser extends Parser {
 			.call(expr, commentsStartPos);
 		if (typeof result === "boolean") return result;
 		switch (expr.type) {
-			// TODO handle more cases
 			case "ClassDeclaration":
 			case "ClassExpression": {
 				if (expr.body.type !== "ClassBody") return false;
@@ -4869,9 +5422,15 @@ class JavascriptParser extends Parser {
 				});
 			}
 			case "TemplateLiteral":
-				return expr.expressions.every((expr) =>
-					this.isPure(expr, /** @type {Range} */ (expr.range)[0])
-				);
+				// Thread `commentsStartPos` through the interpolations so a
+				// /*#__PURE__*/ comment that sits inside `${ ... }` (or before
+				// the first interpolation) is part of the scanned range when
+				// the inner expression's purity is evaluated.
+				return expr.expressions.every((e) => {
+					const pureFlag = this.isPure(e, commentsStartPos);
+					commentsStartPos = /** @type {Range} */ (e.range)[1];
+					return pureFlag;
+				});
 			case "FunctionDeclaration":
 			case "FunctionExpression":
 			case "ArrowFunctionExpression":
@@ -4886,6 +5445,78 @@ class JavascriptParser extends Parser {
 					this.isPure(decl.init, /** @type {Range} */ (decl.range)[0])
 				);
 
+			case "ArrayExpression":
+				return expr.elements.every((element) => {
+					if (element === null) return true;
+					if (element.type === "SpreadElement") return false;
+					const pureFlag = this.isPure(element, commentsStartPos);
+					commentsStartPos = /** @type {Range} */ (element.range)[1];
+					return pureFlag;
+				});
+
+			case "ObjectExpression": {
+				return expr.properties.every((property) => {
+					if (property.type === "SpreadElement") return false;
+
+					if (
+						property.computed &&
+						!this.isPure(property.key, commentsStartPos)
+					) {
+						return false;
+					}
+
+					const pureFlag = this.isPure(
+						/** @type {Exclude<Property["value"], AssignmentPattern | ObjectPattern | ArrayPattern | RestElement>} */
+						(property.value),
+						/** @type {Range} */ (property.key.range)[1]
+					);
+					commentsStartPos = /** @type {Range} */ (property.range)[1];
+					return pureFlag;
+				});
+			}
+
+			case "ChainExpression":
+				return this.isPure(expr.expression, commentsStartPos);
+
+			case "UnaryExpression":
+				// Safe unary operators — produce their result without invoking
+				// user code on the operand:
+				//   - `typeof` returns a type tag and never throws, even for
+				//     undeclared identifiers; no coercion.
+				//   - `void` evaluates the operand and discards it, returning
+				//     `undefined`; pure iff the operand is pure.
+				//   - `!` coerces via ToBoolean, which is defined to not call
+				//     any user code (objects → true, etc.).
+				// Other operators (`+`, `-`, `~`, `delete`) fall through to
+				// the generic evaluator which can still recognize literal
+				// cases (e.g. `-1`, `+5`).
+				if (
+					expr.operator === "typeof" ||
+					expr.operator === "void" ||
+					expr.operator === "!"
+				) {
+					return this.isPure(expr.argument, commentsStartPos);
+				}
+				break;
+
+			case "MetaProperty":
+				return true;
+
+			case "BinaryExpression":
+				// Strict (in)equality compares without coercion and never invokes
+				// user code on its operands, so the result is pure iff both sides
+				// are pure. All other binary operators may invoke `valueOf` /
+				// `toString` / `[Symbol.hasInstance]` / Proxy traps and fall through
+				// to the generic evaluator, which can still recognize the cases
+				// where both sides evaluate to known primitive literals.
+				if (expr.operator === "===" || expr.operator === "!==") {
+					return (
+						this.isPure(expr.left, commentsStartPos) &&
+						this.isPure(expr.right, /** @type {Range} */ (expr.left.range)[1])
+					);
+				}
+				break;
+
 			case "ConditionalExpression":
 				return (
 					this.isPure(expr.test, commentsStartPos) &&
@@ -4921,7 +5552,7 @@ class JavascriptParser extends Parser {
 					]).some(
 						(comment) =>
 							comment.type === "Block" &&
-							/^\s*(?:#|@)__PURE__\s*$/.test(comment.value)
+							CompilerHintNotationRegExp.Pure.test(comment.value)
 					);
 				if (!pureFlag) return false;
 				commentsStartPos = /** @type {Range} */ (expr.callee.range)[1];
@@ -4932,40 +5563,180 @@ class JavascriptParser extends Parser {
 					return pureFlag;
 				});
 			}
+
+			case "NewExpression": {
+				const pureFlag =
+					/** @type {Range} */ (expr.range)[0] - commentsStartPos > 12 &&
+					this.getComments([
+						commentsStartPos,
+						/** @type {Range} */ (expr.range)[0]
+					]).some(
+						(comment) =>
+							comment.type === "Block" &&
+							CompilerHintNotationRegExp.Pure.test(comment.value)
+					);
+				if (!pureFlag) return false;
+				commentsStartPos = /** @type {Range} */ (expr.callee.range)[1];
+				return expr.arguments.every((arg) => {
+					if (arg.type === "SpreadElement") return false;
+					const pureFlag = this.isPure(arg, commentsStartPos);
+					commentsStartPos = /** @type {Range} */ (arg.range)[1];
+					return pureFlag;
+				});
+			}
+
+			case "TaggedTemplateExpression": {
+				const pureFlag =
+					/** @type {Range} */ (expr.range)[0] - commentsStartPos > 12 &&
+					this.getComments([
+						commentsStartPos,
+						/** @type {Range} */ (expr.range)[0]
+					]).some(
+						(comment) =>
+							comment.type === "Block" &&
+							CompilerHintNotationRegExp.Pure.test(comment.value)
+					);
+				if (!pureFlag) return false;
+				commentsStartPos = /** @type {Range} */ (expr.tag.range)[1];
+				return expr.quasi.expressions.every((e) => {
+					const pureFlag = this.isPure(e, commentsStartPos);
+					commentsStartPos = /** @type {Range} */ (e.range)[1];
+					return pureFlag;
+				});
+			}
 		}
 		const evaluated = this.evaluateExpression(expr);
 		return !evaluated.couldHaveSideEffects();
 	}
 
 	/**
+	 * Returns the location of a node or comment, computed from its offsets so
+	 * ASTs from parsers without location support work too. Falls back to the
+	 * node's own `loc` only when no source text is available (preparsed ASTs).
+	 * Offsets can only be mapped while parsing — callbacks deferred past the
+	 * `parse()` call must take the location upfront.
+	 * @param {{ start?: number, end?: number, range?: Range, loc?: SourceLocation | null }} node node or comment
+	 * @returns {DependencyLocation} location of the node
+	 */
+	getLocation(node) {
+		const source = this._source;
+		if (source !== undefined) {
+			const start =
+				typeof node.start === "number"
+					? node.start
+					: node.range
+						? node.range[0]
+						: undefined;
+			if (start !== undefined) {
+				const end =
+					typeof node.end === "number"
+						? node.end
+						: node.range
+							? node.range[1]
+							: start;
+				const lineStarts =
+					this._lineStarts || (this._lineStarts = buildLineStarts(source));
+				return {
+					start: positionAt(lineStarts, start),
+					end: positionAt(lineStarts, end)
+				};
+			}
+		}
+		return /** @type {DependencyLocation} */ (node.loc);
+	}
+
+	/**
+	 * Returns comments in the range.
 	 * @param {Range} range range
 	 * @returns {Comment[]} comments in the range
 	 */
 	getComments(range) {
-		const [rangeStart, rangeEnd] = range;
-		/**
-		 * @param {Comment} comment comment
-		 * @param {number} needle needle
-		 * @returns {number} compared
-		 */
-		const compare = (comment, needle) =>
-			/** @type {Range} */ (comment.range)[0] - needle;
-		const comments = /** @type {Comment[]} */ (this.comments);
-		let idx = binarySearchBounds.ge(comments, rangeStart, compare);
-		/** @type {Comment[]} */
-		const commentsInRange = [];
-		while (
-			comments[idx] &&
-			/** @type {Range} */ (comments[idx].range)[1] <= rangeEnd
-		) {
-			commentsInRange.push(comments[idx]);
-			idx++;
+		return getCommentsInRange(
+			/** @type {(Comment & { range: [number, number] })[]} */ (this.comments),
+			range
+		);
+	}
+
+	/**
+	 * First significant char code at or after `pos`, skipping whitespace,
+	 * comments and grouping `)` (a parenthesized node's range excludes its
+	 * wrapping parens, so a `,`/`;` separator can sit behind them), or -1 at
+	 * end of source.
+	 * @param {string} source source text
+	 * @param {number} pos start offset
+	 * @returns {number} char code of the next token, or -1
+	 */
+	_nextTokenCharCode(source, pos) {
+		const len = source.length;
+		for (let i = pos; i < len; i++) {
+			const c = source.charCodeAt(i);
+			// whitespace and line terminators acorn skips between tokens
+			if (
+				c === 32 ||
+				c === 9 ||
+				c === 10 ||
+				c === 13 ||
+				c === 11 ||
+				c === 12 ||
+				c === 41 /* ) */ ||
+				c === 0xa0 ||
+				c === 0xfeff ||
+				c === 0x2028 ||
+				c === 0x2029
+			) {
+				continue;
+			}
+			if (c === 47 /* / */) {
+				const n = source.charCodeAt(i + 1);
+				if (n === 47 /* / */) {
+					i += 2;
+					while (i < len) {
+						const cc = source.charCodeAt(i);
+						if (cc === 10 || cc === 13 || cc === 0x2028 || cc === 0x2029) break;
+						i++;
+					}
+					continue;
+				}
+				if (n === 42 /* * */) {
+					i += 2;
+					while (
+						i < len &&
+						!(source.charCodeAt(i) === 42 && source.charCodeAt(i + 1) === 47)
+					) {
+						i++;
+					}
+					i++;
+					continue;
+				}
+			}
+			return c;
 		}
+		return -1;
+	}
 
-		return commentsInRange;
+	/**
+	 * Whether a statement ending at `pos` relies on ASI (no real separator).
+	 * Derived from the source text unless overridden by set/unsetAsiPosition.
+	 * A statement terminated by a real `;` or continued by a `,` (a sequence
+	 * element) is not an ASI position; anything else (newline, `}`, eof) is.
+	 * @param {number} pos statement end offset
+	 * @returns {boolean} true when ASI inserts a semicolon at this position
+	 */
+	_isAsiPosition(pos) {
+		if (this.semicolons !== undefined) {
+			const override = this.semicolons.get(pos);
+			if (override !== undefined) return override;
+		}
+		const source = this._source;
+		if (source === undefined) return true;
+		// a real semicolon is the statement's last char (exclusive end at pos)
+		if (source.charCodeAt(pos - 1) === 59 /* ; */) return false;
+		const next = this._nextTokenCharCode(source, pos);
+		return next !== 44 /* , */ && next !== 59; /* ; */
 	}
 
 	/**
+	 * Checks whether this javascript parser is asi position.
 	 * @param {number} pos source code position
 	 * @returns {boolean} true when a semicolon has been inserted before this position, false if not
 	 */
@@ -4981,37 +5752,37 @@ class JavascriptParser extends Parser {
 
 		return (
 			// Either asking directly for the end position of the current statement
-			(range[1] === pos &&
-				/** @type {Set<number>} */ (this.semicolons).has(pos)) ||
+			(range[1] === pos && this._isAsiPosition(pos)) ||
 			// Or asking for the start position of the current statement,
 			// here we have to check multiple things
 			(range[0] === pos &&
 				// is there a previous statement which might be relevant?
 				this.prevStatement !== undefined &&
 				// is the end position of the previous statement an ASI position?
-				/** @type {Set<number>} */ (this.semicolons).has(
-					/** @type {Range} */ (this.prevStatement.range)[1]
-				))
+				this._isAsiPosition(/** @type {Range} */ (this.prevStatement.range)[1]))
 		);
 	}
 
 	/**
+	 * Updates asi position using the provided po.
 	 * @param {number} pos source code position
 	 * @returns {void}
 	 */
 	setAsiPosition(pos) {
-		/** @type {Set<number>} */ (this.semicolons).add(pos);
+		(this.semicolons || (this.semicolons = new Map())).set(pos, true);
 	}
 
 	/**
+	 * Unset asi position.
 	 * @param {number} pos source code position
 	 * @returns {void}
 	 */
 	unsetAsiPosition(pos) {
-		/** @type {Set<number>} */ (this.semicolons).delete(pos);
+		(this.semicolons || (this.semicolons = new Map())).set(pos, false);
 	}
 
 	/**
+	 * Checks whether this javascript parser is statement level expression.
 	 * @param {Expression} expr expression
 	 * @returns {boolean} true, when the expression is a statement level expression
 	 */
@@ -5030,6 +5801,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Returns tag data.
 	 * @param {string} name name
 	 * @param {Tag} tag tag info
 	 * @returns {TagData | undefined} tag data
@@ -5046,6 +5818,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Processes the provided name.
 	 * @param {string} name name
 	 * @param {Tag} tag tag info
 	 * @param {TagData=} data data
@@ -5083,6 +5856,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Processes the provided name.
 	 * @param {string} name variable name
 	 */
 	defineVariable(name) {
@@ -5098,6 +5872,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Processes the provided name.
 	 * @param {string} name variable name
 	 */
 	undefineVariable(name) {
@@ -5105,6 +5880,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Checks whether this javascript parser is variable defined.
 	 * @param {string} name variable name
 	 * @returns {boolean} true, when variable is defined
 	 */
@@ -5118,6 +5894,23 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Whether evaluating an identifier of this name can only fall through:
+	 * the exact negative of the identifier evaluator's `getInfo` — defined in
+	 * some scope and neither free nor tagged nor carrying tag info.
+	 * @param {string} name variable name
+	 * @returns {boolean} true when the identifier evaluates to nothing
+	 */
+	_isDefinedPlainVariable(name) {
+		const info = this.scope.definitions.get(name);
+		if (info === undefined) return false;
+		if (info instanceof VariableInfo) {
+			return !(info.isFree() || info.isTagged() || info.tagInfo !== undefined);
+		}
+		return true;
+	}
+
+	/**
+	 * Gets variable info.
 	 * @param {string} name variable name
 	 * @returns {ExportedVariableInfo} info for this variable
 	 */
@@ -5130,6 +5923,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Updates variable using the provided name.
 	 * @param {string} name variable name
 	 * @param {ExportedVariableInfo} variableInfo new info for this variable
 	 * @returns {void}
@@ -5155,6 +5949,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Evaluated variable.
 	 * @param {TagInfo} tagInfo tag info
 	 * @returns {VariableInfo} variable info
 	 */
@@ -5168,49 +5963,54 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Parses comment options.
 	 * @param {Range} range range of the comment
 	 * @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>} */
-		const options = {};
-		/** @type {(Error & { comment: Comment })[]} */
-		const errors = [];
-		for (const comment of comments) {
-			const { value } = comment;
-			if (value && webpackCommentRegExp.test(value)) {
-				// try compile only if webpack options comment is present
-				try {
-					for (let [key, val] of Object.entries(
-						vm.runInContext(
-							`(function(){return {${value}};})()`,
-							this.magicCommentContext
-						)
-					)) {
-						if (typeof val === "object" && val !== null) {
-							val =
-								val.constructor.name === "RegExp"
-									? new RegExp(val)
-									: JSON.parse(JSON.stringify(val));
-						}
-						options[key] = val;
-					}
-				} catch (err) {
-					const newErr = new Error(String(/** @type {Error} */ (err).message));
-					newErr.stack = String(/** @type {Error} */ (err).stack);
-					Object.assign(newErr, { comment });
-					errors.push(/** @type {(Error & { comment: Comment })} */ (newErr));
+		return parseCommentOptionsInRange(
+			/** @type {(Comment & { range: [number, number], value: string })[]} */ (
+				this.comments
+			),
+			range,
+			this.magicCommentContext
+		);
+	}
+
+	/**
+	 * Finds the root object of a member expression chain without allocating the
+	 * member arrays. The traversal/break logic must stay in sync with
+	 * `extractMemberExpressionChain`; it lets `getMemberExpressionInfo` reject
+	 * unrecognized roots (~77% of calls) before paying for the arrays.
+	 * @param {Expression | Super} expression a member expression
+	 * @returns {Expression | Super} the root object of the chain
+	 */
+	getMemberExpressionRoot(expression) {
+		/** @type {Node} */
+		let expr = expression;
+		while (expr.type === "MemberExpression") {
+			if (expr.computed) {
+				const prop = expr.property;
+				if (
+					prop.type !== "Literal" &&
+					!(
+						prop.type === "TemplateLiteral" &&
+						prop.expressions.length === 0 &&
+						typeof prop.quasis[0].value.cooked === "string"
+					)
+				) {
+					break;
 				}
+			} else if (expr.property.type !== "Identifier") {
+				break;
 			}
+			expr = expr.object;
 		}
-		return { options, errors };
+		return /** @type {Expression | Super} */ (expr);
 	}
 
 	/**
+	 * Extract member expression chain.
 	 * @param {Expression | Super} expression a member expression
 	 * @returns {{ members: Members, object: Expression | Super, membersOptionals: MembersOptionals, memberRanges: MemberRanges }} member names (reverse order) and remaining object
 	 */
@@ -5225,9 +6025,20 @@ class JavascriptParser extends Parser {
 		const memberRanges = [];
 		while (expr.type === "MemberExpression") {
 			if (expr.computed) {
-				if (expr.property.type !== "Literal") break;
-				members.push(`${expr.property.value}`); // the literal
-				memberRanges.push(/** @type {Range} */ (expr.object.range)); // the range of the expression fragment before the literal
+				const prop = expr.property;
+				if (prop.type === "Literal") {
+					members.push(`${prop.value}`); // the literal
+				} else if (
+					prop.type === "TemplateLiteral" &&
+					prop.expressions.length === 0 &&
+					typeof prop.quasis[0].value.cooked === "string"
+				) {
+					// `[`url`]` is statically a string just like `["url"]`
+					members.push(prop.quasis[0].value.cooked);
+				} else {
+					break;
+				}
+				memberRanges.push(/** @type {Range} */ (expr.object.range)); // the range of the expression fragment before the property
 			} else {
 				if (expr.property.type !== "Identifier") break;
 				members.push(expr.property.name); // the identifier
@@ -5246,6 +6057,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Gets free info from variable.
 	 * @param {string} varName variable name
 	 * @returns {{ name: string, info: VariableInfo | string } | undefined} name of the free variable and variable info for that
 	 */
@@ -5265,6 +6077,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Gets name info from variable.
 	 * @param {string} varName variable name
 	 * @returns {{ name: string, info: VariableInfo | string } | undefined} name of the free variable and variable info for that
 	 */
@@ -5287,38 +6100,45 @@ class JavascriptParser extends Parser {
 	/** @typedef {{ type: "expression", rootInfo: string | VariableInfo, name: string, getMembers: () => Members, getMembersOptionals: () => MembersOptionals, getMemberRanges: () => MemberRanges }} ExpressionExpressionInfo */
 
 	/**
+	 * Gets member expression info.
 	 * @param {Expression | Super} expression a member expression
 	 * @param {number} allowedTypes which types should be returned, presented in bit mask
 	 * @returns {CallExpressionInfo | ExpressionExpressionInfo | undefined} expression info
 	 */
 	getMemberExpressionInfo(expression, allowedTypes) {
-		const { object, members, membersOptionals, memberRanges } =
-			this.extractMemberExpressionChain(expression);
+		// Resolve the root first (no allocation); most calls reject here and so
+		// never build the member arrays via extractMemberExpressionChain.
+		const object = this.getMemberExpressionRoot(expression);
 		switch (object.type) {
 			case "CallExpression": {
 				if ((allowedTypes & ALLOWED_MEMBER_TYPES_CALL_EXPRESSION) === 0) return;
-				let callee = object.callee;
-				let rootMembers = EMPTY_ARRAY;
-				if (callee.type === "MemberExpression") {
-					({ object: callee, members: rootMembers } =
-						this.extractMemberExpressionChain(callee));
-				}
+				const calleeExpr = object.callee;
+				const callee =
+					calleeExpr.type === "MemberExpression"
+						? this.getMemberExpressionRoot(calleeExpr)
+						: calleeExpr;
 				const rootName = getRootName(callee);
 				if (!rootName) return;
 				const result = this.getNameInfoFromVariable(rootName);
 				if (!result) return;
 				const { info: rootInfo, name: resolvedRoot } = result;
+				const rootMembers =
+					calleeExpr.type === "MemberExpression"
+						? this.extractMemberExpressionChain(calleeExpr).members
+						: EMPTY_ARRAY;
+				const { members, membersOptionals, memberRanges } =
+					this.extractMemberExpressionChain(expression);
 				const calleeName = objectAndMembersToName(resolvedRoot, rootMembers);
 				return {
 					type: "call",
 					call: object,
 					calleeName,
 					rootInfo,
-					getCalleeMembers: memoize(() => rootMembers.reverse()),
+					getCalleeMembers: lazyReverse(rootMembers),
 					name: objectAndMembersToName(`${calleeName}()`, members),
-					getMembers: memoize(() => members.reverse()),
-					getMembersOptionals: memoize(() => membersOptionals.reverse()),
-					getMemberRanges: memoize(() => memberRanges.reverse())
+					getMembers: lazyReverse(members),
+					getMembersOptionals: lazyReverse(membersOptionals),
+					getMemberRanges: lazyReverse(memberRanges)
 				};
 			}
 			case "Identifier":
@@ -5331,19 +6151,22 @@ class JavascriptParser extends Parser {
 				const result = this.getNameInfoFromVariable(rootName);
 				if (!result) return;
 				const { info: rootInfo, name: resolvedRoot } = result;
+				const { members, membersOptionals, memberRanges } =
+					this.extractMemberExpressionChain(expression);
 				return {
 					type: "expression",
 					name: objectAndMembersToName(resolvedRoot, members),
 					rootInfo,
-					getMembers: memoize(() => members.reverse()),
-					getMembersOptionals: memoize(() => membersOptionals.reverse()),
-					getMemberRanges: memoize(() => memberRanges.reverse())
+					getMembers: lazyReverse(members),
+					getMembersOptionals: lazyReverse(membersOptionals),
+					getMemberRanges: lazyReverse(memberRanges)
 				};
 			}
 		}
 	}
 
 	/**
+	 * Gets name for expression.
 	 * @param {Expression} expression an expression
 	 * @returns {{ name: string, rootInfo: ExportedVariableInfo, getMembers: () => Members } | undefined} name info
 	 */
@@ -5355,6 +6178,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Get module parse function.
 	 * @param {Compilation} compilation compilation
 	 * @param {Module} module module
 	 * @returns {ParseFunction | undefined} parser
@@ -5375,6 +6199,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
+	 * Returns parse result.
 	 * @param {string} code source code
 	 * @param {InternalParseOptions} options parsing options
 	 * @param {ParseFunction=} customParse custom function to parse
@@ -5383,13 +6208,32 @@ class JavascriptParser extends Parser {
 	static _parse(code, options, customParse) {
 		const type = options ? options.sourceType : "module";
 		/** @type {ParseOptions} */
-		const parserOptions = {
-			...defaultParserOptions,
-			allowReturnOutsideFunction: type === "script",
-			...options,
-			sourceType: type === "auto" ? "module" : type
-		};
+		let parserOptions;
+		if (typeof customParse === "function") {
+			// a user parse function may retain the options object — keep it fresh
+			parserOptions = {
+				...defaultParserOptions,
+				allowReturnOutsideFunction: type === "script",
+				...options,
+				sourceType: type === "auto" ? "module" : type
+			};
+		} else {
+			// reuse one options object across parses (parsing is synchronous) to
+			// skip re-materializing it per module; acorn copies it via getOptions.
+			// Every non-default key a caller may pass must be reset here.
+			parserOptions = REUSED_PARSER_OPTIONS;
+			parserOptions.importPhases = false;
+			Object.assign(parserOptions, defaultParserOptions);
+			parserOptions.allowReturnOutsideFunction = type === "script";
+			if (options) Object.assign(parserOptions, options);
+			parserOptions.sourceType = type === "auto" ? "module" : type;
+			// let WebpackParser downgrade module->script in place on script-only
+			// syntax so `auto` avoids a second full parse in the common case
+			parserOptions.moduleFallback = type === "auto";
+		}
+		const wantRanges = parserOptions.ranges === true;
 		/**
+		 * Returns parse result.
 		 * @param {string} code source code
 		 * @param {ParseOptions} options parsing options
 		 * @returns {ParseResult} parse result
@@ -5402,36 +6246,46 @@ class JavascriptParser extends Parser {
 			/** @type {Comment[]} */
 			const comments = [];
 
-			if (options.comments) {
-				/** @type {AcornOptions} */
-				(options).onComment = comments;
+			// Whenever ranges are wanted (the main parse path and the concatenation
+			// re-parse), have the parser plugin serve `range` on demand instead of
+			// eagerly. `wantRanges` is hoisted since the auto-fallback re-enters
+			// with the same (mutated) options object.
+			options.lazyNodes = wantRanges;
+			if (wantRanges) {
+				// the lazy plugin replaces acorn's native tracking — disabling it
+				// here lets WebpackParser skip its defensive options copy
+				options.locations = false;
+				options.ranges = false;
 			}
 
-			/** @type {Set<number>} */
-			const semicolons = new Set();
-
-			if (options.semicolons) {
-				/** @type {AcornOptions} */
-				(options).onInsertedSemicolon = (pos) => semicolons.add(pos);
+			if (options.comments) {
+				if (wantRanges) {
+					// the parser plugin collects the comments itself, deferring the
+					// text slice until some hook actually reads `value`
+					options.lazyComments = comments;
+				} else {
+					/** @type {AcornOptions} */
+					(options).onComment =
+						/** @type {import("acorn").Comment[]} */
+						(/** @type {unknown} */ (comments));
+				}
 			}
 
 			const ast =
 				/** @type {Program} */
 				(parser.parse(code, /** @type {AcornOptions} */ (options)));
 
-			return { ast, comments, semicolons };
+			return { ast, comments };
 		};
 
 		/** @type {Program | undefined} */
 		let ast;
 		/** @type {Comment[] | undefined} */
 		let comments;
-		/** @type {Set<number> | undefined} */
-		let semicolons;
 		let error;
 		let threw = false;
 		try {
-			({ ast, comments, semicolons } = internalParse(code, parserOptions));
+			({ ast, comments } = internalParse(code, parserOptions));
 		} catch (err) {
 			error = err;
 			threw = true;
@@ -5440,9 +6294,11 @@ class JavascriptParser extends Parser {
 		if (threw && type === "auto") {
 			parserOptions.sourceType = "script";
 			parserOptions.allowReturnOutsideFunction = true;
+			// the retry is already a full script parse — no in-place downgrade
+			parserOptions.moduleFallback = false;
 
 			try {
-				({ ast, comments, semicolons } = internalParse(code, parserOptions));
+				({ ast, comments } = internalParse(code, parserOptions));
 				threw = false;
 			} catch (_err) {
 				// we use the error from first parse try
@@ -5450,15 +6306,22 @@ class JavascriptParser extends Parser {
 			}
 		}
 
+		// release per-parse state retained on the (possibly reused) options
+		// object — the comments array retains source text slices
+		parserOptions.lazyComments = undefined;
+		/** @type {AcornOptions} */
+		(parserOptions).onComment = undefined;
+
 		if (threw) {
 			throw error;
 		}
 
-		return /** @type {ParseResult} */ ({ ast, comments, semicolons });
+		return /** @type {ParseResult} */ ({ ast, comments });
 	}
 
 	/**
-	 * @param {((BaseParser: typeof AcornParser) => typeof AcornParser)[]} plugins parser plugin
+	 * Returns parser.
+	 * @param {((BaseParser: AcornParser) => AcornParser)[]} plugins parser plugin
 	 * @returns {typeof JavascriptParser} parser
 	 */
 	static extend(...plugins) {