webpack 5.108.4 → 5.109.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 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 */
@@ -156,77 +165,21 @@ 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 {
-		/**
-		 * Parses with clause.
-		 * @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);
-			}
+// Shared `() => false` so the members-optionals fallback in walkCallExpression
+// doesn't allocate a fresh closure per identifier-rooted call.
+const RETURN_FALSE = () => false;
 
-			if (isAssertLegacy) {
-				/** @type {EXPECTED_ANY} */
-				(nodes)[LEGACY_ASSERT_ATTRIBUTES] = true;
-			}
-
-			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
@@ -362,9 +315,12 @@ class VariableInfo {
  * @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
  */
 
 /**
@@ -372,7 +328,6 @@ class VariableInfo {
  * @typedef {object} ParseResult
  * @property {Program} ast
  * @property {Comment[]} comments
- * @property {Set<number>} semicolons
  */
 
 /**
@@ -424,10 +379,10 @@ const SCOPE_INFO_TERMINATED_THROW = 2;
 
 /**
  * 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
  */
@@ -527,10 +482,16 @@ 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";
 
@@ -538,7 +499,7 @@ class JavascriptParser extends Parser {
 	/**
 	 * Creates an instance of JavascriptParser.
 	 * @param {"module" | "script" | "auto"=} sourceType default source type
-	 * @param {{ parse?: ParseFunction, typescript?: boolean }=} options parser options
+	 * @param {{ parse?: ParseFunction, typescript?: boolean, importPhases?: boolean, strictModeViolations?: "error" | "warn" | false }=} options parser options
 	 */
 	constructor(sourceType = "auto", options = {}) {
 		super();
@@ -571,9 +532,15 @@ 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>>} */
+			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>>} */
+			blockPreStatementByType: new HookMap(
+				() => new SyncBailHook(["declaration"])
+			),
 			/** @type {SyncBailHook<[Statement | ModuleDeclaration | MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration], boolean | void>} */
 			statement: new SyncBailHook(["statement"]),
 			/** @type {SyncBailHook<[IfStatement], boolean | void>} */
@@ -744,7 +711,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;
@@ -754,11 +724,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() {
@@ -1607,9 +1605,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
 				};
 			}
 		});
@@ -1622,9 +1620,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
 				};
 			}
 		});
@@ -2073,6 +2071,15 @@ class JavascriptParser extends Parser {
 	 * @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;
@@ -2212,49 +2219,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;
@@ -2271,27 +2289,37 @@ class JavascriptParser extends Parser {
 	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} */
@@ -2305,51 +2333,42 @@ class JavascriptParser extends Parser {
 	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);
@@ -2357,15 +2376,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;
@@ -2521,6 +2555,12 @@ class JavascriptParser extends Parser {
 	 * @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);
@@ -2809,6 +2849,9 @@ class JavascriptParser extends Parser {
 	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);
@@ -3253,7 +3296,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
 				});
@@ -3270,7 +3312,6 @@ class JavascriptParser extends Parser {
 					props.add({
 						id: str,
 						range: /** @type {Range} */ (key.range),
-						loc: /** @type {SourceLocation} */ (key.loc),
 						pattern,
 						shorthand: this.scope.inShorthand
 					});
@@ -3307,7 +3348,6 @@ class JavascriptParser extends Parser {
 			props.add({
 				id: `${i}`,
 				range: /** @type {Range} */ (element.range),
-				loc: /** @type {SourceLocation} */ (element.loc),
 				pattern,
 				shorthand: false
 			});
@@ -3467,6 +3507,12 @@ class JavascriptParser extends Parser {
 	 */
 	walkPattern(pattern) {
 		switch (pattern.type) {
+			// 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;
@@ -3476,9 +3522,6 @@ class JavascriptParser extends Parser {
 			case "MemberExpression":
 				this.walkMemberExpression(pattern);
 				break;
-			case "ObjectPattern":
-				this.walkObjectPattern(pattern);
-				break;
 			case "RestElement":
 				this.walkRestElement(pattern);
 				break;
@@ -3548,78 +3591,86 @@ class JavascriptParser extends Parser {
 	 * @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);
@@ -3627,6 +3678,35 @@ 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
@@ -3710,6 +3790,9 @@ class JavascriptParser extends Parser {
 			? [...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);
@@ -3733,6 +3816,9 @@ class JavascriptParser extends Parser {
 	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);
@@ -3794,9 +3880,84 @@ class JavascriptParser extends Parser {
 	 * @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
@@ -3817,10 +3978,39 @@ 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
@@ -3859,6 +4049,9 @@ class JavascriptParser extends Parser {
 	 */
 	walkAssignmentExpression(expression) {
 		if (expression.left.type === "Identifier") {
+			if (this._strictInModuleOutput) {
+				this._checkStrictModeAssignTarget(expression.left.name, expression);
+			}
 			const renameIdentifier = this.getRenameIdentifier(expression.right);
 			if (
 				renameIdentifier &&
@@ -3960,38 +4153,6 @@ class JavascriptParser extends Parser {
 	 * @param {NewExpression} expression new expression
 	 */
 	walkNewExpression(expression) {
-		// TODO acorn-import-phases bug: it omits acorn's `!forNew` guard, so
-		// `import.defer(...)`/`import.source(...)` are wrongly accepted as `new`
-		// operands; drop once fixed. Parenthesized forms stay valid (check `(`).
-		if (typeof this.state.source === "string") {
-			let base = expression.callee;
-			while (
-				base.type === "MemberExpression" ||
-				base.type === "CallExpression"
-			) {
-				base = base.type === "MemberExpression" ? base.object : base.callee;
-			}
-			if (base.type === "ImportExpression") {
-				const newStart = /** @type {Range} */ (expression.range)[0];
-				const importStart = /** @type {Range} */ (base.range)[0];
-				const between = this.state.source
-					.slice(newStart, importStart)
-					.replace(/\/\*[\s\S]*?\*\//g, "")
-					.replace(/\/\/[^\n]*/g, "");
-				if (!between.includes("(")) {
-					const err =
-						/** @type {SyntaxError & { loc?: { line: number, column: number } }} */
-						(new SyntaxError("import call cannot be the target of `new`"));
-					if (expression.loc) {
-						err.loc = {
-							line: expression.loc.start.line,
-							column: expression.loc.start.column
-						};
-					}
-					throw err;
-				}
-			}
-		}
 		const result = this.callHooksForExpression(
 			this.hooks.new,
 			expression.callee,
@@ -4233,19 +4394,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;
@@ -4749,22 +4924,14 @@ class JavascriptParser extends Parser {
 	 */
 	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;
@@ -4774,6 +4941,15 @@ 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;
 		}
 	}
 
@@ -4861,9 +5037,9 @@ 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);
 	}
 
 	/**
@@ -5002,30 +5178,21 @@ class JavascriptParser extends Parser {
 		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
 			));
@@ -5037,6 +5204,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,
@@ -5049,12 +5228,32 @@ 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);
@@ -5071,6 +5270,10 @@ 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;
 	}
 
@@ -5080,11 +5283,41 @@ class JavascriptParser extends Parser {
 	 * @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");
 		}
@@ -5343,34 +5576,127 @@ class JavascriptParser extends Parser {
 		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;
-		/**
-		 * Returns compared.
-		 * @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 and
+	 * comments, 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 === 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; /* ; */
 	}
 
 	/**
@@ -5390,17 +5716,14 @@ 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]))
 		);
 	}
 
@@ -5410,7 +5733,7 @@ class JavascriptParser extends Parser {
 	 * @returns {void}
 	 */
 	setAsiPosition(pos) {
-		/** @type {Set<number>} */ (this.semicolons).add(pos);
+		(this.semicolons || (this.semicolons = new Map())).set(pos, true);
 	}
 
 	/**
@@ -5419,7 +5742,7 @@ class JavascriptParser extends Parser {
 	 * @returns {void}
 	 */
 	unsetAsiPosition(pos) {
-		/** @type {Set<number>} */ (this.semicolons).delete(pos);
+		(this.semicolons || (this.semicolons = new Map())).set(pos, false);
 	}
 
 	/**
@@ -5534,6 +5857,22 @@ class JavascriptParser extends Parser {
 		return true;
 	}
 
+	/**
+	 * 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
@@ -5593,42 +5932,13 @@ class JavascriptParser extends Parser {
 	 * @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 { options, errors };
+		return parseCommentOptionsInRange(
+			/** @type {(Comment & { range: [number, number], value: string })[]} */ (
+				this.comments
+			),
+			range,
+			this.magicCommentContext
+		);
 	}
 
 	/**
@@ -5862,12 +6172,30 @@ 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
@@ -5882,36 +6210,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;
@@ -5920,9 +6258,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
@@ -5930,16 +6270,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 });
 	}
 
 	/**
 	 * Returns parser.
-	 * @param {((BaseParser: typeof AcornParser) => typeof AcornParser)[]} plugins parser plugin
+	 * @param {((BaseParser: AcornParser) => AcornParser)[]} plugins parser plugin
 	 * @returns {typeof JavascriptParser} parser
 	 */
 	static extend(...plugins) {