webpack 5.111.0 → 5.112.0

package/lib/javascript/JavascriptParser.js

@@ -6,10 +6,9 @@
 "use strict";
 
 const { HookMap, SyncBailHook } = require("tapable");
-const NormalModule = require("../NormalModule");
-const Parser = require("../Parser");
 const WebpackError = require("../WebpackError");
-const StackedMap = require("../util/StackedMap");
+const Parser = require("../module/Parser");
+const binarySearchBounds = require("../util/binarySearchBounds");
 const {
 	CompilerHintNotationRegExp,
 	createMagicCommentContext,
@@ -17,16 +16,24 @@ const {
 	parseCommentOptionsInRange
 } = require("../util/magicComment");
 const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
+const StackedMap = require("./StackedMap");
+const { nonASCIIwhitespace } = require("./syntax-parser");
 const {
+	BLOCK_DECLARATIONS,
+	HOISTED_DECLARATIONS,
 	LEGACY_ASSERT_ATTRIBUTES,
+	MAX_MASKED_INDEX,
+	MODULE_DECLARATIONS,
 	WebpackParser,
 	buildLineStarts,
+	declaresIntoBlock,
 	hasOctalEscape,
 	isIdentifierChar,
+	overflowFrom,
 	positionAt
-} = require("./syntax");
+} = require("./syntax-parser");
 
-/** @import { EcmaVersion, ParserOptions, ParserPlugin } from "./syntax" */
+/** @import { EcmaVersion, ParserOptions, ParserPlugin } from "./syntax-parser" */
 /**
  * @import {
  * 	AssignmentExpression,
@@ -101,42 +108,50 @@ const {
  * 	MaybeNamedClassDeclaration
  * } from "estree"
  */
-/** @import { DependencyLocation } from "../Dependency" */
+/** @import { DependencyLocation } from "../graph/Dependency" */
+/** @import { MagicCommentOptions } from "../util/magicComment" */
 /** @typedef {import("estree").Comment & { start: number, end: number, loc?: SourceLocation | null }} Comment */
 /**
  * Defines the shared type used by this module.
  * @template T
  * @typedef {import("tapable").AsArray<T>} AsArray<T>
  */
-/** @import { ParserState, PreparsedAst } from "../Parser" */
+/** @import { ParserState, PreparsedAst } from "../module/Parser" */
 
-/** @import LocalModule from "../dependencies/LocalModule" */
+/** @import LocalModule from "../dependencies/amd/LocalModule" */
 /**
  * @import {
- * 	HarmonyStarExportsList
- * } from "../dependencies/HarmonyExportImportedSpecifierDependency"
+ * 	ESMStarExportsList
+ * } from "../dependencies/esm/ESMExportImportedSpecifierDependency"
  */
 
 /**
  * Defines the known javascript parser state type used by this module.
+ * The `harmony*` properties forward to their `esm*` namesake.
  * @typedef {object} KnownJavascriptParserState
- * @property {Set<string>=} harmonyNamedExports
- * @property {InstanceType<HarmonyStarExportsList>=} harmonyStarExports
- * @property {number=} lastHarmonyImportOrder
+ * @property {Set<string>=} esmNamedExports
+ * @property {InstanceType<ESMStarExportsList>=} esmStarExports
+ * @property {number=} lastESMImportOrder
  * @property {LocalModule[]=} localModules
+ * @property {Set<string>=} harmonyNamedExports deprecated, use `esmNamedExports`
+ * @property {InstanceType<ESMStarExportsList>=} harmonyStarExports deprecated, use `esmStarExports`
+ * @property {number=} lastHarmonyImportOrder deprecated, use `lastESMImportOrder`
  */
 
 /** @typedef {ParserState & KnownJavascriptParserState} JavascriptParserState */
 
 /** @import Compilation from "../Compilation" */
-/** @import Module from "../Module" */
+/** @import Module from "../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 {{ consequent?: GuardFrame, alternate?: GuardFrame }} 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 */
 /** @typedef {StatementPathItem[]} StatementPath */
+/** @typedef {(Statement | ModuleDeclaration)[]} HoistedDeclarations the declarations one scope hoists, in source order */
+/** @typedef {(ModuleDeclaration | Statement | undefined)[]} ModuleDeclarations the program's import and re-export declarations in source order, each followed by the statement written before it */
+/** @typedef {number | number[]} BlockDeclarations which statements of one list declare into its block scope: a mask of their indices, or the indices themselves once one is too large to mask */
 
 /** @typedef {Set<DestructuringAssignmentProperty>} DestructuringAssignmentProperties */
 
@@ -145,6 +160,32 @@ const {
 
 /** @type {string[]} */
 const EMPTY_ARRAY = [];
+/** @type {HoistedDeclarations} */
+const EMPTY_HOISTED_DECLARATIONS = [];
+// what the module pass reports; `export default` is the block pass's
+const MODULE_STATEMENT_TYPES = new Set([
+	"ImportDeclaration",
+	"ExportNamedDeclaration",
+	"ExportAllDeclaration"
+]);
+// what the parser records per scope, and so what the hoisting pass reaches
+const RECORDED_STATEMENT_TYPES = new Set([
+	"VariableDeclaration",
+	"FunctionDeclaration",
+	"ClassDeclaration"
+]);
+/** @type {ModuleDeclarations} */
+const EMPTY_MODULE_DECLARATIONS = [];
+// what the parser records per statement list, and so what the block pass
+// reaches. An expression statement is recorded only when it assigns to an
+// object pattern, so a tap on that type is not served from the list.
+const BLOCK_DECLARATION_TYPES = new Set([
+	"VariableDeclaration",
+	"ClassDeclaration",
+	"ExportNamedDeclaration",
+	"ExportDefaultDeclaration"
+]);
+
 /** @type {MembersOptionals} */
 const EMPTY_MEMBERS_OPTIONALS = [];
 
@@ -237,7 +278,10 @@ const getImportAttributes = (node) => {
 		result[key] = /** @type {string} */ (attribute.value.value);
 	}
 
-	if (/** @type {EXPECTED_ANY} */ (node.attributes)[LEGACY_ASSERT_ATTRIBUTES]) {
+	if (
+		/** @type {typeof node.attributes & { [LEGACY_ASSERT_ATTRIBUTES]?: boolean }} */
+		(node.attributes)[LEGACY_ASSERT_ATTRIBUTES]
+	) {
 		result._isLegacyAssert = true;
 	}
 
@@ -329,19 +373,20 @@ class VariableInfo {
 
 /**
  * @import {
- * 	HarmonySettings
- * } from "../dependencies/HarmonyImportDependencyParserPlugin"
+ * 	ESMSettings
+ * } from "../dependencies/esm/ESMImportDependencyParserPlugin"
  */
-/** @import { ImportSettings } from "../dependencies/ImportParserPlugin" */
+/** @import { ImportSettings } from "../dependencies/import/ImportParserPlugin" */
+/** @import { GuardFrame } from "../dependencies/esm/ESMImportGuard" */
 /**
  * @import {
  * 	CommonJsImportSettings
- * } from "../dependencies/CommonJsImportsParserPlugin"
+ * } from "../dependencies/commonjs/CommonJsImportsParserPlugin"
  */
-/** @import { CompatibilitySettings } from "../CompatibilityPlugin" */
+/** @import { CompatibilitySettings } from "./CompatibilityPlugin" */
 /** @import { TopLevelSymbol } from "../optimize/InnerGraph" */
 
-/** @typedef {HarmonySettings | ImportSettings | CommonJsImportSettings | TopLevelSymbol | CompatibilitySettings} KnownTagData */
+/** @typedef {ESMSettings | ImportSettings | CommonJsImportSettings | TopLevelSymbol | CompatibilitySettings} KnownTagData */
 /** @typedef {KnownTagData | Record<string, EXPECTED_ANY>} TagData */
 
 /**
@@ -354,6 +399,7 @@ class VariableInfo {
 
 /** @typedef {string[]} CalleeMembers */
 /** @typedef {string[]} Members */
+/** @typedef {UpdateExpression | ForInStatement | ForOfStatement | AssignmentExpression} WriteStatement a construct that writes to the reference it carries */
 /** @typedef {boolean[]} MembersOptionals */
 /** @typedef {Range[]} MemberRanges */
 
@@ -517,123 +563,138 @@ const valueAsExpression = (value, expr, sideEffects) => {
 };
 
 // The constant operators, shared so evaluating `a - b` allocates no handler.
+// JavaScript coerces any operand; each cast only lets TypeScript type the operator.
+
+/** @typedef {ReturnType<BasicEvaluatedExpression["asCompileTimeValue"]>} CompileTimeValue */
 
 /**
- * @param {EXPECTED_ANY} l left operand
- * @param {EXPECTED_ANY} r right operand
- * @returns {EXPECTED_ANY} the result
+ * @param {CompileTimeValue} l left operand
+ * @param {CompileTimeValue} r right operand
+ * @returns {number | bigint} the result
  */
-const SUBTRACT = (l, r) => l - r;
+const SUBTRACT = (l, r) =>
+	/** @type {number} */ (l) - /** @type {number} */ (r);
 
 /**
- * @param {EXPECTED_ANY} l left operand
- * @param {EXPECTED_ANY} r right operand
- * @returns {EXPECTED_ANY} the result
+ * @param {CompileTimeValue} l left operand
+ * @param {CompileTimeValue} r right operand
+ * @returns {number | bigint} the result
  */
-const MULTIPLY = (l, r) => l * r;
+const MULTIPLY = (l, r) =>
+	/** @type {number} */ (l) * /** @type {number} */ (r);
 
 /**
- * @param {EXPECTED_ANY} l left operand
- * @param {EXPECTED_ANY} r right operand
- * @returns {EXPECTED_ANY} the result
+ * @param {CompileTimeValue} l left operand
+ * @param {CompileTimeValue} r right operand
+ * @returns {number | bigint} the result
  */
-const DIVIDE = (l, r) => l / r;
+const DIVIDE = (l, r) => /** @type {number} */ (l) / /** @type {number} */ (r);
 
 /**
- * @param {EXPECTED_ANY} l left operand
- * @param {EXPECTED_ANY} r right operand
- * @returns {EXPECTED_ANY} the result
+ * @param {CompileTimeValue} l left operand
+ * @param {CompileTimeValue} r right operand
+ * @returns {number | bigint} the result
  */
-const POWER = (l, r) => l ** r;
+const POWER = (l, r) => /** @type {number} */ (l) ** /** @type {number} */ (r);
 
 /**
- * @param {EXPECTED_ANY} l left operand
- * @param {EXPECTED_ANY} r right operand
- * @returns {EXPECTED_ANY} the result
+ * @param {CompileTimeValue} l left operand
+ * @param {CompileTimeValue} r right operand
+ * @returns {number | bigint} the result
  */
-const BITWISE_AND = (l, r) => l & r;
+const BITWISE_AND = (l, r) =>
+	/** @type {number} */ (l) & /** @type {number} */ (r);
 
 /**
- * @param {EXPECTED_ANY} l left operand
- * @param {EXPECTED_ANY} r right operand
- * @returns {EXPECTED_ANY} the result
+ * @param {CompileTimeValue} l left operand
+ * @param {CompileTimeValue} r right operand
+ * @returns {number | bigint} the result
  */
-const BITWISE_OR = (l, r) => l | r;
+const BITWISE_OR = (l, r) =>
+	/** @type {number} */ (l) | /** @type {number} */ (r);
 
 /**
- * @param {EXPECTED_ANY} l left operand
- * @param {EXPECTED_ANY} r right operand
- * @returns {EXPECTED_ANY} the result
+ * @param {CompileTimeValue} l left operand
+ * @param {CompileTimeValue} r right operand
+ * @returns {number | bigint} the result
  */
-const BITWISE_XOR = (l, r) => l ^ r;
+const BITWISE_XOR = (l, r) =>
+	/** @type {number} */ (l) ^ /** @type {number} */ (r);
 
 /**
- * @param {EXPECTED_ANY} l left operand
- * @param {EXPECTED_ANY} r right operand
- * @returns {EXPECTED_ANY} the result
+ * @param {CompileTimeValue} l left operand
+ * @param {CompileTimeValue} r right operand
+ * @returns {number} the result
  */
-const UNSIGNED_SHIFT_RIGHT = (l, r) => l >>> r;
+const UNSIGNED_SHIFT_RIGHT = (l, r) =>
+	/** @type {number} */ (l) >>> /** @type {number} */ (r);
 
 /**
- * @param {EXPECTED_ANY} l left operand
- * @param {EXPECTED_ANY} r right operand
- * @returns {EXPECTED_ANY} the result
+ * @param {CompileTimeValue} l left operand
+ * @param {CompileTimeValue} r right operand
+ * @returns {number | bigint} the result
  */
-const SHIFT_RIGHT = (l, r) => l >> r;
+const SHIFT_RIGHT = (l, r) =>
+	/** @type {number} */ (l) >> /** @type {number} */ (r);
 
 /**
- * @param {EXPECTED_ANY} l left operand
- * @param {EXPECTED_ANY} r right operand
- * @returns {EXPECTED_ANY} the result
+ * @param {CompileTimeValue} l left operand
+ * @param {CompileTimeValue} r right operand
+ * @returns {number | bigint} the result
  */
-const SHIFT_LEFT = (l, r) => l << r;
+const SHIFT_LEFT = (l, r) =>
+	/** @type {number} */ (l) << /** @type {number} */ (r);
 
 /**
- * @param {EXPECTED_ANY} l left operand
- * @param {EXPECTED_ANY} r right operand
- * @returns {EXPECTED_ANY} the result
+ * @param {CompileTimeValue} l left operand
+ * @param {CompileTimeValue} r right operand
+ * @returns {boolean} the result
  */
-const LESS_THAN = (l, r) => l < r;
+const LESS_THAN = (l, r) =>
+	/** @type {number} */ (l) < /** @type {number} */ (r);
 
 /**
- * @param {EXPECTED_ANY} l left operand
- * @param {EXPECTED_ANY} r right operand
- * @returns {EXPECTED_ANY} the result
+ * @param {CompileTimeValue} l left operand
+ * @param {CompileTimeValue} r right operand
+ * @returns {boolean} the result
  */
-const GREATER_THAN = (l, r) => l > r;
+const GREATER_THAN = (l, r) =>
+	/** @type {number} */ (l) > /** @type {number} */ (r);
 
 /**
- * @param {EXPECTED_ANY} l left operand
- * @param {EXPECTED_ANY} r right operand
- * @returns {EXPECTED_ANY} the result
+ * @param {CompileTimeValue} l left operand
+ * @param {CompileTimeValue} r right operand
+ * @returns {boolean} the result
  */
-const LESS_THAN_OR_EQUAL = (l, r) => l <= r;
+const LESS_THAN_OR_EQUAL = (l, r) =>
+	/** @type {number} */ (l) <= /** @type {number} */ (r);
 
 /**
- * @param {EXPECTED_ANY} l left operand
- * @param {EXPECTED_ANY} r right operand
- * @returns {EXPECTED_ANY} the result
+ * @param {CompileTimeValue} l left operand
+ * @param {CompileTimeValue} r right operand
+ * @returns {boolean} the result
  */
-const GREATER_THAN_OR_EQUAL = (l, r) => l >= r;
+const GREATER_THAN_OR_EQUAL = (l, r) =>
+	/** @type {number} */ (l) >= /** @type {number} */ (r);
 
 /**
- * @param {EXPECTED_ANY} v operand
- * @returns {EXPECTED_ANY} the result
+ * @param {CompileTimeValue} v operand
+ * @returns {number | bigint} the result
  */
-const BITWISE_NOT = (v) => ~v;
+const BITWISE_NOT = (v) => ~(/** @type {number} */ (v));
 
 /**
- * @param {EXPECTED_ANY} v operand
- * @returns {EXPECTED_ANY} the result
+ * @param {CompileTimeValue} v operand
+ * @returns {number} the result
  */
 // eslint-disable-next-line no-implicit-coercion
-const TO_NUMBER = (v) => +v;
+const TO_NUMBER = (v) => +(/** @type {number} */ (v));
 
 /**
- * @param {EXPECTED_ANY} v operand
- * @returns {EXPECTED_ANY} the result
+ * @param {CompileTimeValue} v operand
+ * @returns {number | bigint} the result
  */
-const NEGATE = (v) => -v;
+const NEGATE = (v) => -(/** @type {number} */ (v));
 
 /**
  * Evaluates a binary expression if and only if it is a const operation (e.g. 1 + 2, "a" + "b", etc.).
@@ -922,6 +983,195 @@ const evaluateAstCaches = new WeakMap();
 // The inner map is strong while the compilation lives, so cap it
 const EVALUATE_AST_CACHE_LIMIT = 4096;
 
+/**
+ * Add one declaration, starting the list at the first — most scopes declare
+ * nothing, and the shared empty list spares them an array.
+ * @param {HoistedDeclarations} hoisted the list so far
+ * @param {Statement | ModuleDeclaration} declaration what to add
+ * @returns {HoistedDeclarations} the list holding it
+ */
+const addHoistedDeclaration = (hoisted, declaration) => {
+	if (hoisted === EMPTY_HOISTED_DECLARATIONS) return [declaration];
+	hoisted.push(declaration);
+	return hoisted;
+};
+
+/**
+ * Collect the declarations that hoist to one scope, for an AST that did not
+ * come from webpack's parser and so carries no record of its own.
+ * @param {(Statement | ModuleDeclaration)[]} statements the scope's statements
+ * @param {HoistedDeclarations} hoisted the list so far
+ * @returns {HoistedDeclarations} the list holding what they declare
+ */
+const collectHoistedDeclarations = (statements, hoisted) => {
+	for (let index = 0, len = statements.length; index < len; index++) {
+		hoisted = collectHoistedDeclaration(statements[index], hoisted);
+	}
+	return hoisted;
+};
+
+/**
+ * Collect from one statement, descending exactly as far as a `var` reaches:
+ * through blocks and loop bodies, never into another function.
+ * @param {Statement | ModuleDeclaration} statement the statement
+ * @param {HoistedDeclarations} hoisted the list so far
+ * @returns {HoistedDeclarations} the list holding what it declares
+ */
+const collectHoistedDeclaration = (statement, hoisted) => {
+	switch (statement.type) {
+		case "VariableDeclaration":
+			if (statement.kind === "var") {
+				hoisted = addHoistedDeclaration(hoisted, statement);
+			}
+			break;
+		case "FunctionDeclaration":
+		case "ClassDeclaration":
+			hoisted = addHoistedDeclaration(hoisted, statement);
+			break;
+		case "BlockStatement":
+			hoisted = collectHoistedDeclarations(statement.body, hoisted);
+			break;
+		case "IfStatement":
+			hoisted = collectHoistedDeclaration(statement.consequent, hoisted);
+			if (statement.alternate) {
+				hoisted = collectHoistedDeclaration(statement.alternate, hoisted);
+			}
+			break;
+		case "ForStatement":
+			if (statement.init && statement.init.type === "VariableDeclaration") {
+				hoisted = collectHoistedDeclaration(statement.init, hoisted);
+			}
+			hoisted = collectHoistedDeclaration(statement.body, hoisted);
+			break;
+		case "ForInStatement":
+		case "ForOfStatement":
+			if (statement.left.type === "VariableDeclaration") {
+				hoisted = collectHoistedDeclaration(statement.left, hoisted);
+			}
+			hoisted = collectHoistedDeclaration(statement.body, hoisted);
+			break;
+		case "WhileStatement":
+		case "DoWhileStatement":
+		case "LabeledStatement":
+		case "WithStatement":
+			hoisted = collectHoistedDeclaration(statement.body, hoisted);
+			break;
+		case "TryStatement":
+			hoisted = collectHoistedDeclaration(statement.block, hoisted);
+			if (statement.handler) {
+				hoisted = collectHoistedDeclaration(statement.handler.body, hoisted);
+			}
+			if (statement.finalizer) {
+				hoisted = collectHoistedDeclaration(statement.finalizer, hoisted);
+			}
+			break;
+		case "SwitchStatement": {
+			const cases = statement.cases;
+			for (let index = 0, len = cases.length; index < len; index++) {
+				hoisted = collectHoistedDeclarations(cases[index].consequent, hoisted);
+			}
+			break;
+		}
+	}
+	return hoisted;
+};
+
+/**
+ * What the program imports and re-exports: the parser's own record, or a scan
+ * of the top-level statements for an AST some other parser built.
+ * @param {Program} ast the program
+ * @param {boolean} trusted whether the parser's own record may be read
+ * @returns {ModuleDeclarations} the declarations, in source order
+ */
+const moduleDeclarationsOf = (ast, trusted) => {
+	if (trusted) {
+		const recorded =
+			/** @type {Program & { [MODULE_DECLARATIONS]?: ModuleDeclarations }} */
+			(ast)[MODULE_DECLARATIONS];
+		if (recorded !== undefined) return recorded;
+	}
+	/** @type {ModuleDeclarations} */
+	let declarations = EMPTY_MODULE_DECLARATIONS;
+	const body = ast.body;
+	for (let index = 0, len = body.length; index < len; index++) {
+		const statement = body[index];
+		if (MODULE_STATEMENT_TYPES.has(statement.type)) {
+			if (declarations === EMPTY_MODULE_DECLARATIONS) declarations = [];
+			declarations.push(statement, index === 0 ? undefined : body[index - 1]);
+		}
+	}
+	return declarations;
+};
+
+/**
+ * What hoists to the scope the node opens: the parser's own record, or a walk
+ * of the body for an AST some other parser built.
+ * @param {Program | BlockStatement} node the node owning the scope
+ * @param {boolean} trusted whether the parser's own record may be read
+ * @returns {HoistedDeclarations} the declarations, in source order
+ */
+const hoistedDeclarationsOf = (node, trusted) => {
+	if (trusted) {
+		const recorded =
+			/** @type {(Program | BlockStatement) & { [HOISTED_DECLARATIONS]?: HoistedDeclarations }} */
+			(node)[HOISTED_DECLARATIONS];
+		if (recorded !== undefined) return recorded;
+	}
+	return collectHoistedDeclarations(node.body, EMPTY_HOISTED_DECLARATIONS);
+};
+
+/**
+ * Which statements of a list declare into its block scope, scanned for an AST
+ * some other parser built. The parser's own record is read instead when there
+ * is one.
+ * @param {(Statement | ModuleDeclaration)[]} statements the list
+ * @returns {BlockDeclarations} their indices, in source order
+ */
+const collectBlockDeclarations = (statements) => {
+	let mask = 0;
+	/** @type {number[] | undefined} */
+	let overflow;
+	for (let index = 0, len = statements.length; index < len; index++) {
+		if (!declaresIntoBlock(statements[index])) continue;
+		if (overflow !== undefined) overflow.push(index);
+		else if (index <= MAX_MASKED_INDEX) mask |= 1 << index;
+		else overflow = overflowFrom(mask, index);
+	}
+	return overflow === undefined ? mask : overflow;
+};
+
+/**
+ * @param {Comment} comment comment to compare
+ * @param {number} position source offset
+ * @returns {number} comparison of the comment end with the offset
+ */
+const compareCommentEnd = (comment, position) =>
+	/** @type {Range} */ (comment.range)[1] - position;
+
+/**
+ * Whether the source between two offsets is whitespace only.
+ * @param {string} source the module source
+ * @param {number} start where to start
+ * @param {number} end where to stop
+ * @returns {boolean} whether nothing but whitespace lies between them
+ */
+const onlyWhitespaceBetween = (source, start, end) => {
+	for (let index = start; index < end; index++) {
+		const code = source.charCodeAt(index);
+		// the classification `skipSpace` uses: anything else is a token, and a
+		// token means the run of comments before the statement has ended
+		if (
+			code !== 32 &&
+			code !== 160 &&
+			!(code > 8 && code < 14) &&
+			!(code >= 5760 && nonASCIIwhitespace.test(source[index]))
+		) {
+			return false;
+		}
+	}
+	return true;
+};
+
 const CLASS_NAME = "JavascriptParser";
 
 // Reserved words in strict mode, so unusable as binding names there (12.7.2).
@@ -984,17 +1234,33 @@ class JavascriptParser extends Parser {
 			isPure: new HookMap(
 				() => new SyncBailHook(["expression", "commentsStartPosition"])
 			),
-			/** @type {SyncBailHook<[Statement | ModuleDeclaration | MaybeNamedClassDeclaration | MaybeNamedFunctionDeclaration], boolean | void>} */
+			/**
+			 * Every statement the hoisting pass reads, which a tap on this turns
+			 * back into a walk of them all. Tap `preStatementByType` instead.
+			 * @type {SyncBailHook<[Statement | ModuleDeclaration | MaybeNamedClassDeclaration | MaybeNamedFunctionDeclaration], boolean | void>}
+			 * @deprecated TODO in the next major release: remove, with the statement walk it turns on
+			 */
 			preStatement: new SyncBailHook(["statement"]),
 			/**
+			 * Each declaration the parser records: a variable, function or class
+			 * one. Any other type turns the pass back into a walk of every
+			 * statement, and goes away with that walk in the next major release.
 			 * @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>} */
+			/**
+			 * Every statement the block pass reads, which a tap on this turns back
+			 * into a walk of them all. Tap `blockPreStatementByType` instead.
+			 * @type {SyncBailHook<[Statement | ModuleDeclaration | MaybeNamedClassDeclaration | MaybeNamedFunctionDeclaration], boolean | void>}
+			 * @deprecated TODO in the next major release: remove, with the statement walk it turns on
+			 */
 			blockPreStatement: new SyncBailHook(["declaration"]),
 			/**
+			 * Each statement the parser records for the block pass: a variable, class
+			 * or export declaration. Any other type turns the pass back into a walk
+			 * of every statement, and goes away with that walk in the next major release.
 			 * @type {HookMap<SyncBailHook<[Statement | ModuleDeclaration | MaybeNamedClassDeclaration | MaybeNamedFunctionDeclaration], boolean | void>>}
 			 * @since 5.109.0
 			 */
@@ -1092,6 +1358,12 @@ class JavascriptParser extends Parser {
 			rename: new HookMap(() => new SyncBailHook(["initExpression"])),
 			/** @type {HookMap<SyncBailHook<[AssignmentExpression], boolean | void>>} */
 			assign: new HookMap(() => new SyncBailHook(["expression"])),
+			/** @type {HookMap<SyncBailHook<[WriteStatement], boolean | void>>} */
+			write: new HookMap(() => new SyncBailHook(["node"])),
+			/** @type {HookMap<SyncBailHook<[WriteStatement, Members], boolean | void>>} */
+			writeMemberChain: new HookMap(
+				() => new SyncBailHook(["node", "members"])
+			),
 			/** @type {HookMap<SyncBailHook<[AssignmentExpression, Members], boolean | void>>} */
 			assignMemberChain: new HookMap(
 				() => new SyncBailHook(["expression", "members"])
@@ -1201,6 +1473,37 @@ class JavascriptParser extends Parser {
 		this.statementPath = undefined;
 		/** @type {Statement | ModuleDeclaration | Expression | MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration | undefined} */
 		this.prevStatement = undefined;
+		/** @type {boolean} */
+		this._hasParserRecord = false;
+		// BACKWARD-COMPAT START
+
+		// WHY: the hoisting pass reaches declarations alone, so a tap that
+		// expects every statement would quietly stop seeing most of them. Such a
+		// tap turns the pass back into the walk it used to be, which no build
+		// webpack's own plugins drive ever asks for.
+		/** @type {boolean} */
+		this._needsFullPreWalk = false;
+		this.hooks.preStatementByType.intercept({
+			factory: (type, hook) => {
+				if (!RECORDED_STATEMENT_TYPES.has(type)) {
+					this._needsFullPreWalk = true;
+				}
+				return hook;
+			}
+		});
+
+		// The same for the block pass, over the types the parser records for it.
+		/** @type {boolean} */
+		this._needsFullBlockPreWalk = false;
+		this.hooks.blockPreStatementByType.intercept({
+			factory: (type, hook) => {
+				if (!BLOCK_DECLARATION_TYPES.has(type)) {
+					this._needsFullBlockPreWalk = true;
+				}
+				return hook;
+			}
+		});
+		// BACKWARD-COMPAT END
 		/** @type {WeakMap<Expression, DestructuringAssignmentProperties> | undefined} */
 		this.destructuringAssignmentProperties = undefined;
 		/** @type {TagData | undefined} */
@@ -1835,7 +2138,7 @@ class JavascriptParser extends Parser {
 			const info = this.getVariableInfo(/** @type {Identifier} */ (expr).name);
 			if (
 				typeof info === "string" ||
-				(info instanceof VariableInfo &&
+				(JavascriptParser.isVariableInfo(info) &&
 					(info.isFree() ||
 						info.isTagged() ||
 						// Walk `tagInfo` in `callHooksForInfo` if tagInfo is present.
@@ -1854,7 +2157,8 @@ class JavascriptParser extends Parser {
 			const info = this.getVariableInfo("this");
 			if (
 				typeof info === "string" ||
-				(info instanceof VariableInfo && (info.isFree() || info.isTagged()))
+				(JavascriptParser.isVariableInfo(info) &&
+					(info.isFree() || info.isTagged()))
 			) {
 				return {
 					name: info,
@@ -2378,12 +2682,19 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
-	 * Module pre walking iterates the scope for import entries
-	 * @param {(Statement | ModuleDeclaration)[]} statements statements
+	 * Report what the program imports and re-exports, before anything reads a
+	 * name. The list is what the parser recorded, in source order.
+	 * @param {ModuleDeclarations} declarations the program's module declarations
 	 */
-	modulePreWalkStatements(statements) {
-		for (let index = 0, len = statements.length; index < len; index++) {
-			const statement = statements[index];
+	_modulePreWalkDeclarations(declarations) {
+		for (let index = 0, len = declarations.length; index < len; index += 2) {
+			const statement =
+				/** @type {ModuleDeclaration} */
+				(declarations[index]);
+			// what precedes it decides whether removing it joins two statements
+			this.prevStatement =
+				/** @type {Statement | undefined} */
+				(declarations[index + 1]);
 			/** @type {StatementPath} */
 			(this.statementPath).push(statement);
 			switch (statement.type) {
@@ -2404,19 +2715,212 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
-	 * Pre walking iterates the scope for variable declarations
+	 * Declare what the scope the node opens hoists, before anything reads a
+	 * name in it.
+	 * @param {Program | BlockStatement} node the node owning the scope
+	 */
+	_preWalkScope(node) {
+		// BACKWARD-COMPAT START
+		if (this._needsFullPreWalk || this.hooks.preStatement.taps.length !== 0) {
+			if (node.type === "Program") this.preWalkStatements(node.body);
+			else this.preWalkStatement(node);
+			return;
+		}
+		// BACKWARD-COMPAT END
+		this._preWalkHoistedDeclarations(
+			hoistedDeclarationsOf(node, this._hasParserRecord)
+		);
+	}
+
+	/**
+	 * Declare what hoists to the scope being entered, from what the parser
+	 * recorded while reading it. `prevStatement` is not available here.
+	 * @param {HoistedDeclarations} hoisted what the scope declares
+	 */
+	_preWalkHoistedDeclarations(hoisted) {
+		for (let index = 0, len = hoisted.length; index < len; index++) {
+			// WHY: the statements between two declarations are not read here, so
+			// the one before this declaration is unknown rather than the previous
+			// declaration. A tap needing it taps `preStatement`, which walks.
+			this.prevStatement = undefined;
+			this.preWalkStatement(hoisted[index]);
+		}
+	}
+
+	// BACKWARD-COMPAT START
+	/**
+	 * Walk every statement of a scope to declare what hoists to it. Only a tap
+	 * on the deprecated `preStatement` hook asks for this.
 	 * @param {(Statement | ModuleDeclaration)[]} statements statements
+	 * @deprecated TODO in the next major release: remove, with the `preStatement` hook
 	 */
 	preWalkStatements(statements) {
+		for (let index = 0, len = statements.length; index < len; index++) {
+			this.preWalkStatement(statements[index]);
+		}
+	}
+
+	/**
+	 * Pre walk block statement.
+	 * @param {BlockStatement} statement block statement
+	 * @deprecated TODO in the next major release: remove, with the `preStatement` hook
+	 */
+	preWalkBlockStatement(statement) {
+		this.preWalkStatements(statement.body);
+	}
+
+	/**
+	 * Pre walk if statement.
+	 * @param {IfStatement} statement if statement
+	 * @deprecated TODO in the next major release: remove, with the `preStatement` hook
+	 */
+	preWalkIfStatement(statement) {
+		this.preWalkStatement(statement.consequent);
+		if (statement.alternate) {
+			this.preWalkStatement(statement.alternate);
+		}
+	}
+
+	/**
+	 * Pre walk labeled statement.
+	 * @param {LabeledStatement} statement labeled statement
+	 * @deprecated TODO in the next major release: remove, with the `preStatement` hook
+	 */
+	preWalkLabeledStatement(statement) {
+		this.preWalkStatement(statement.body);
+	}
+
+	/**
+	 * Pre walk with statement.
+	 * @param {WithStatement} statement with statement
+	 * @deprecated TODO in the next major release: remove, with the `preStatement` hook
+	 */
+	preWalkWithStatement(statement) {
+		this.preWalkStatement(statement.body);
+	}
+
+	/**
+	 * Pre walk switch statement.
+	 * @param {SwitchStatement} statement switch statement
+	 * @deprecated TODO in the next major release: remove, with the `preStatement` hook
+	 */
+	preWalkSwitchStatement(statement) {
+		this.preWalkSwitchCases(statement.cases);
+	}
+
+	/**
+	 * Pre walk switch cases.
+	 * @param {SwitchCase[]} switchCases switch cases
+	 * @deprecated TODO in the next major release: remove, with the `preStatement` hook
+	 */
+	preWalkSwitchCases(switchCases) {
+		for (let index = 0, len = switchCases.length; index < len; index++) {
+			this.preWalkStatements(switchCases[index].consequent);
+		}
+	}
+
+	/**
+	 * Pre walk try statement.
+	 * @param {TryStatement} statement try statement
+	 * @deprecated TODO in the next major release: remove, with the `preStatement` hook
+	 */
+	preWalkTryStatement(statement) {
+		this.preWalkStatement(statement.block);
+		if (statement.handler) this.preWalkCatchClause(statement.handler);
+		if (statement.finalizer) this.preWalkStatement(statement.finalizer);
+	}
+
+	/**
+	 * Pre walk catch clause.
+	 * @param {CatchClause} catchClause catch clause
+	 * @deprecated TODO in the next major release: remove, with the `preStatement` hook
+	 */
+	preWalkCatchClause(catchClause) {
+		this.preWalkStatement(catchClause.body);
+	}
+
+	/**
+	 * Pre walk while statement.
+	 * @param {WhileStatement} statement while statement
+	 * @deprecated TODO in the next major release: remove, with the `preStatement` hook
+	 */
+	preWalkWhileStatement(statement) {
+		this.preWalkStatement(statement.body);
+	}
+
+	/**
+	 * Pre walk do while statement.
+	 * @param {DoWhileStatement} statement do while statement
+	 * @deprecated TODO in the next major release: remove, with the `preStatement` hook
+	 */
+	preWalkDoWhileStatement(statement) {
+		this.preWalkStatement(statement.body);
+	}
+
+	/**
+	 * Pre walk for statement.
+	 * @param {ForStatement} statement for statement
+	 * @deprecated TODO in the next major release: remove, with the `preStatement` hook
+	 */
+	preWalkForStatement(statement) {
+		if (statement.init && statement.init.type === "VariableDeclaration") {
+			this.preWalkStatement(statement.init);
+		}
+		this.preWalkStatement(statement.body);
+	}
+
+	/**
+	 * Pre walk for in statement.
+	 * @param {ForInStatement} statement for in statement
+	 * @deprecated TODO in the next major release: remove, with the `preStatement` hook
+	 */
+	preWalkForInStatement(statement) {
+		if (statement.left.type === "VariableDeclaration") {
+			this.preWalkStatement(statement.left);
+		}
+		this.preWalkStatement(statement.body);
+	}
+
+	/**
+	 * Pre walk for of statement. `for await` is reported by the walk, not here.
+	 * @param {ForOfStatement} statement for of statement
+	 * @deprecated TODO in the next major release: remove, with the `preStatement` hook
+	 */
+	preWalkForOfStatement(statement) {
+		if (statement.left.type === "VariableDeclaration") {
+			this.preWalkStatement(statement.left);
+		}
+		this.preWalkStatement(statement.body);
+	}
+
+	/**
+	 * Scan every top-level statement for the program's module declarations.
+	 * The parser records them now, so nothing inside webpack scans for them.
+	 * @deprecated TODO in the next major release: remove
+	 * @param {(Statement | ModuleDeclaration)[]} statements statements
+	 */
+	modulePreWalkStatements(statements) {
+		/** @type {ModuleDeclarations} */
+		const declarations = [];
 		for (let index = 0, len = statements.length; index < len; index++) {
 			const statement = statements[index];
-			this.preWalkStatement(statement);
+			if (MODULE_STATEMENT_TYPES.has(statement.type)) {
+				declarations.push(
+					statement,
+					index === 0 ? undefined : statements[index - 1]
+				);
+			}
 		}
+		this._modulePreWalkDeclarations(declarations);
 	}
+	// BACKWARD-COMPAT END
 
+	// BACKWARD-COMPAT START
 	/**
-	 * Block pre walking iterates the scope for block variable declarations
+	 * Walk every statement of a list to declare what it binds. Only a tap on the
+	 * deprecated `blockPreStatement` hook asks for this.
 	 * @param {(Statement | ModuleDeclaration)[]} statements statements
+	 * @deprecated TODO in the next major release: remove, with the `blockPreStatement` hook
 	 */
 	blockPreWalkStatements(statements) {
 		for (let index = 0, len = statements.length; index < len; index++) {
@@ -2424,6 +2928,70 @@ class JavascriptParser extends Parser {
 			this.blockPreWalkStatement(statement);
 		}
 	}
+	// BACKWARD-COMPAT END
+
+	/**
+	 * Declare what the statement list binds into its own block scope, before any
+	 * of it is walked. The list is what the parser recorded while reading it.
+	 * @param {Program | BlockStatement | StaticBlock | SwitchCase} node the node owning the list
+	 * @param {(Statement | ModuleDeclaration)[]} statements the list it holds
+	 */
+	_blockPreWalkScope(node, statements) {
+		// BACKWARD-COMPAT START
+		if (
+			this._needsFullBlockPreWalk ||
+			this.hooks.blockPreStatement.taps.length !== 0
+		) {
+			this.blockPreWalkStatements(statements);
+			return;
+		}
+		// BACKWARD-COMPAT END
+		/** @type {BlockDeclarations | undefined} */
+		let recorded;
+		if (this._hasParserRecord) {
+			recorded =
+				/** @type {typeof node & { [BLOCK_DECLARATIONS]?: BlockDeclarations }} */
+				(node)[BLOCK_DECLARATIONS];
+			// 72.8% of the lists a build reads declare nothing, and saying so is
+			// the whole pass for them
+			if (recorded === 0) return;
+		}
+		if (recorded === undefined) {
+			recorded = collectBlockDeclarations(statements);
+			if (recorded === 0) return;
+		}
+		this._blockPreWalkDeclarations(statements, recorded);
+	}
+
+	/**
+	 * Declare what the recorded statements of the list bind, in source order.
+	 * @param {(Statement | ModuleDeclaration)[]} statements the whole list
+	 * @param {BlockDeclarations} declarations which of them declare
+	 */
+	_blockPreWalkDeclarations(statements, declarations) {
+		if (typeof declarations === "number") {
+			for (let bits = declarations; bits !== 0; bits &= bits - 1) {
+				this._blockPreWalkAt(statements, 31 - Math.clz32(bits & -bits));
+			}
+			return;
+		}
+		for (let index = 0, len = declarations.length; index < len; index++) {
+			this._blockPreWalkAt(statements, declarations[index]);
+		}
+	}
+
+	/**
+	 * Declare what one statement of the list binds, with the statement written
+	 * before it, so a tap reading `prevStatement` sees what the walk would show.
+	 * @param {(Statement | ModuleDeclaration)[]} statements the whole list
+	 * @param {number} index which statement declares
+	 */
+	_blockPreWalkAt(statements, index) {
+		// the first statement of the list has nothing before it, and leaves
+		// whatever the caller set standing, as walking the whole list did
+		if (index !== 0) this.prevStatement = statements[index - 1];
+		this.blockPreWalkStatement(statements[index]);
+	}
 
 	/**
 	 * Walking iterates the statements and expressions and processes them
@@ -2473,21 +3041,22 @@ class JavascriptParser extends Parser {
 				(this.statementPath).pop();
 			return;
 		}
-		// cases ordered by measured statement frequency; the commonest statements
-		// (expressions, returns) intentionally match nothing here
+		// a class declaration reaches here for the typed hook alone: defining it
+		// is the block pass's. The rest are only walked into by the deprecated
+		// statement walk, which a tap expecting every statement turns back on.
 		switch (statement.type) {
 			case "VariableDeclaration":
 				this.preWalkVariableDeclaration(statement);
 				break;
+			case "FunctionDeclaration":
+				this.preWalkFunctionDeclaration(statement);
+				break;
 			case "IfStatement":
 				this.preWalkIfStatement(statement);
 				break;
 			case "BlockStatement":
 				this.preWalkBlockStatement(statement);
 				break;
-			case "FunctionDeclaration":
-				this.preWalkFunctionDeclaration(statement);
-				break;
 			case "ForStatement":
 				this.preWalkForStatement(statement);
 				break;
@@ -2660,13 +3229,6 @@ class JavascriptParser extends Parser {
 	}
 
 	// Real Statements
-	/**
-	 * Pre walk block statement.
-	 * @param {BlockStatement} statement block statement
-	 */
-	preWalkBlockStatement(statement) {
-		this.preWalkStatements(statement.body);
-	}
 
 	/**
 	 * Walk block statement.
@@ -2676,7 +3238,7 @@ class JavascriptParser extends Parser {
 		const oldScope = this._enterBlockScope();
 		const body = statement.body;
 		const prev = this.prevStatement;
-		this.blockPreWalkStatements(body);
+		this._blockPreWalkScope(statement, body);
 		this.prevStatement = prev;
 		this.walkStatements(body);
 
@@ -2691,21 +3253,10 @@ class JavascriptParser extends Parser {
 		this.walkExpression(statement.expression);
 	}
 
-	/**
-	 * Pre walk if statement.
-	 * @param {IfStatement} statement if statement
-	 */
-	preWalkIfStatement(statement) {
-		this.preWalkStatement(statement.consequent);
-		if (statement.alternate) {
-			this.preWalkStatement(statement.alternate);
-		}
-	}
-
 	/**
 	 * 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 {GuardFrame | undefined | null} frame guard frame, or falsy when the branch is unguarded
 	 * @param {() => void} walk branch walk
 	 * @returns {void}
 	 */
@@ -2768,14 +3319,6 @@ class JavascriptParser extends Parser {
 		}
 	}
 
-	/**
-	 * Pre walk labeled statement.
-	 * @param {LabeledStatement} statement with statement
-	 */
-	preWalkLabeledStatement(statement) {
-		this.preWalkStatement(statement.body);
-	}
-
 	/**
 	 * Walk labeled statement.
 	 * @param {LabeledStatement} statement with statement
@@ -2792,14 +3335,6 @@ class JavascriptParser extends Parser {
 		this._exitBlockScope(oldScope, false);
 	}
 
-	/**
-	 * Pre walk with statement.
-	 * @param {WithStatement} statement with statement
-	 */
-	preWalkWithStatement(statement) {
-		this.preWalkStatement(statement.body);
-	}
-
 	/**
 	 * Walk with statement.
 	 * @param {WithStatement} statement with statement
@@ -2818,14 +3353,6 @@ class JavascriptParser extends Parser {
 		this._exitBlockScope(oldScope, false);
 	}
 
-	/**
-	 * Pre walk switch statement.
-	 * @param {SwitchStatement} statement switch statement
-	 */
-	preWalkSwitchStatement(statement) {
-		this.preWalkSwitchCases(statement.cases);
-	}
-
 	/**
 	 * Walk switch statement.
 	 * @param {SwitchStatement} statement switch statement
@@ -2867,16 +3394,6 @@ class JavascriptParser extends Parser {
 		this.walkTerminatingStatement(statement);
 	}
 
-	/**
-	 * Pre walk try statement.
-	 * @param {TryStatement} statement try statement
-	 */
-	preWalkTryStatement(statement) {
-		this.preWalkStatement(statement.block);
-		if (statement.handler) this.preWalkCatchClause(statement.handler);
-		if (statement.finalizer) this.preWalkStatement(statement.finalizer);
-	}
-
 	/**
 	 * Walk try statement.
 	 * @param {TryStatement} statement try statement
@@ -2915,14 +3432,6 @@ class JavascriptParser extends Parser {
 		}
 	}
 
-	/**
-	 * Pre walk while statement.
-	 * @param {WhileStatement} statement while statement
-	 */
-	preWalkWhileStatement(statement) {
-		this.preWalkStatement(statement.body);
-	}
-
 	/**
 	 * Walk while statement.
 	 * @param {WhileStatement} statement while statement
@@ -2935,14 +3444,6 @@ class JavascriptParser extends Parser {
 		this._exitBlockScope(oldScope, false);
 	}
 
-	/**
-	 * Pre walk do while statement.
-	 * @param {DoWhileStatement} statement do while statement
-	 */
-	preWalkDoWhileStatement(statement) {
-		this.preWalkStatement(statement.body);
-	}
-
 	/**
 	 * Walk do while statement.
 	 * @param {DoWhileStatement} statement do while statement
@@ -2955,17 +3456,6 @@ class JavascriptParser extends Parser {
 		this._exitBlockScope(oldScope, false);
 	}
 
-	/**
-	 * Pre walk for statement.
-	 * @param {ForStatement} statement for statement
-	 */
-	preWalkForStatement(statement) {
-		if (statement.init && statement.init.type === "VariableDeclaration") {
-			this.preWalkStatement(statement.init);
-		}
-		this.preWalkStatement(statement.body);
-	}
-
 	/**
 	 * Walk for statement.
 	 * @param {ForStatement} statement for statement
@@ -2993,7 +3483,7 @@ class JavascriptParser extends Parser {
 		if (body.type === "BlockStatement") {
 			// no need to add additional scope
 			const prev = this.prevStatement;
-			this.blockPreWalkStatements(body.body);
+			this._blockPreWalkScope(body, body.body);
 			this.prevStatement = prev;
 			this.walkStatements(body.body);
 		} else {
@@ -3003,17 +3493,6 @@ class JavascriptParser extends Parser {
 		this._exitBlockScope(oldScope, false);
 	}
 
-	/**
-	 * Pre walk for in statement.
-	 * @param {ForInStatement} statement for statement
-	 */
-	preWalkForInStatement(statement) {
-		if (statement.left.type === "VariableDeclaration") {
-			this.preWalkVariableDeclaration(statement.left);
-		}
-		this.preWalkStatement(statement.body);
-	}
-
 	/**
 	 * Walk for in statement.
 	 * @param {ForInStatement} statement for statement
@@ -3023,7 +3502,7 @@ class JavascriptParser extends Parser {
 		if (statement.left.type === "VariableDeclaration") {
 			this.blockPreWalkVariableDeclaration(statement.left);
 			this.walkVariableDeclaration(statement.left);
-		} else {
+		} else if (!this._walkWriteTarget(statement.left, statement)) {
 			this.walkPattern(statement.left);
 		}
 
@@ -3034,7 +3513,7 @@ class JavascriptParser extends Parser {
 		if (body.type === "BlockStatement") {
 			// no need to add additional scope
 			const prev = this.prevStatement;
-			this.blockPreWalkStatements(body.body);
+			this._blockPreWalkScope(body, body.body);
 			this.prevStatement = prev;
 			this.walkStatements(body.body);
 		} else {
@@ -3044,30 +3523,19 @@ class JavascriptParser extends Parser {
 		this._exitBlockScope(oldScope, false);
 	}
 
-	/**
-	 * Pre walk for of statement.
-	 * @param {ForOfStatement} statement statement
-	 */
-	preWalkForOfStatement(statement) {
-		if (statement.await && this.scope.topLevelScope === true) {
-			this.hooks.topLevelAwait.call(statement);
-		}
-		if (statement.left.type === "VariableDeclaration") {
-			this.preWalkVariableDeclaration(statement.left);
-		}
-		this.preWalkStatement(statement.body);
-	}
-
 	/**
 	 * Walk for of statement.
 	 * @param {ForOfStatement} statement for statement
 	 */
 	walkForOfStatement(statement) {
+		if (statement.await && this.scope.topLevelScope === true) {
+			this.hooks.topLevelAwait.call(statement);
+		}
 		const oldScope = this._enterBlockScope();
 		if (statement.left.type === "VariableDeclaration") {
 			this.blockPreWalkVariableDeclaration(statement.left);
 			this.walkVariableDeclaration(statement.left);
-		} else {
+		} else if (!this._walkWriteTarget(statement.left, statement)) {
 			this.walkPattern(statement.left);
 		}
 
@@ -3078,7 +3546,7 @@ class JavascriptParser extends Parser {
 		if (body.type === "BlockStatement") {
 			// no need to add additional scope
 			const prev = this.prevStatement;
-			this.blockPreWalkStatements(body.body);
+			this._blockPreWalkScope(body, body.body);
 			this.prevStatement = prev;
 			this.walkStatements(body.body);
 		} else {
@@ -3120,7 +3588,7 @@ class JavascriptParser extends Parser {
 
 		const prev = this.prevStatement;
 
-		this.preWalkStatement(statement.body);
+		this._preWalkScope(statement.body);
 		this.prevStatement = prev;
 		this.walkStatement(statement.body);
 
@@ -3698,17 +4166,6 @@ class JavascriptParser extends Parser {
 		this.walkClass(statement);
 	}
 
-	/**
-	 * Pre walk switch cases.
-	 * @param {SwitchCase[]} switchCases switch statement
-	 */
-	preWalkSwitchCases(switchCases) {
-		for (let index = 0, len = switchCases.length; index < len; index++) {
-			const switchCase = switchCases[index];
-			this.preWalkStatements(switchCase.consequent);
-		}
-	}
-
 	/**
 	 * Processes the provided switch case.
 	 * @param {SwitchCase[]} switchCases switch statement
@@ -3724,7 +4181,7 @@ class JavascriptParser extends Parser {
 
 			if (switchCase.consequent.length > 0) {
 				const prev = this.prevStatement;
-				this.blockPreWalkStatements(switchCase.consequent);
+				this._blockPreWalkScope(switchCase, switchCase.consequent);
 				this.prevStatement = prev;
 			}
 		}
@@ -3745,14 +4202,6 @@ class JavascriptParser extends Parser {
 		this._exitBlockScope(oldScope, false);
 	}
 
-	/**
-	 * Pre walk catch clause.
-	 * @param {CatchClause} catchClause catch clause
-	 */
-	preWalkCatchClause(catchClause) {
-		this.preWalkStatement(catchClause.body);
-	}
-
 	/**
 	 * Processes the provided catch clause.
 	 * @param {CatchClause} catchClause catch clause
@@ -4081,7 +4530,7 @@ class JavascriptParser extends Parser {
 
 		const prev = this.prevStatement;
 
-		this.preWalkStatement(expression.body);
+		this._preWalkScope(expression.body);
 		this.prevStatement = prev;
 		this.walkStatement(expression.body);
 
@@ -4106,7 +4555,7 @@ class JavascriptParser extends Parser {
 		if (expression.body.type === "BlockStatement") {
 			this.detectMode(expression.body.body);
 			const prev = this.prevStatement;
-			this.preWalkStatement(expression.body);
+			this._preWalkScope(expression.body);
 			this.prevStatement = prev;
 			this.walkStatement(expression.body);
 		} else {
@@ -4167,9 +4616,98 @@ class JavascriptParser extends Parser {
 		) {
 			this._checkStrictModeAssignTarget(expression.argument.name, expression);
 		}
+		if (this._walkWriteTarget(expression.argument, expression)) return;
 		this.walkExpression(expression.argument);
 	}
 
+	/**
+	 * Offers a write that is not an assignment's left side — an update's target
+	 * or a loop's binding — to the taps that care, `assign` carrying only an
+	 * AssignmentExpression.
+	 * @param {Expression | Pattern} target the written reference
+	 * @param {WriteStatement} node the construct performing the write
+	 * @returns {boolean} true when a tap rendered the write itself
+	 */
+	_walkWriteTarget(target, node) {
+		if (target.type === "Identifier") {
+			return Boolean(
+				this._callHooksForName1(this.hooks.write, target.name, node)
+			);
+		}
+		if (target.type.endsWith("Pattern")) {
+			this.enterPattern(/** @type {Pattern} */ (target), (name) => {
+				this._callHooksForName1(this.hooks.write, name, node);
+			});
+			this._walkPatternWriteMembers(target, node);
+			return false;
+		}
+		return Boolean(
+			target.type === "MemberExpression" &&
+			this._callWriteMemberChain(target, node)
+		);
+	}
+
+	/**
+	 * Offers the member expressions a destructuring target writes to the
+	 * `writeMemberChain` taps, which `enterPattern` passes over because they
+	 * bind no name.
+	 * @param {Pattern | Expression | null} pattern the destructuring target
+	 * @param {WriteStatement} node the construct performing the write
+	 * @returns {void}
+	 */
+	_walkPatternWriteMembers(pattern, node) {
+		if (!pattern) return;
+		switch (pattern.type) {
+			case "MemberExpression":
+				this._callWriteMemberChain(pattern, node);
+				break;
+			case "ObjectPattern":
+				for (const property of pattern.properties) {
+					this._walkPatternWriteMembers(
+						property.type === "RestElement"
+							? property.argument
+							: /** @type {Pattern} */ (property.value),
+						node
+					);
+				}
+				break;
+			case "ArrayPattern":
+				for (const element of pattern.elements) {
+					this._walkPatternWriteMembers(element, node);
+				}
+				break;
+			case "AssignmentPattern":
+				this._walkPatternWriteMembers(pattern.left, node);
+				break;
+			case "RestElement":
+				this._walkPatternWriteMembers(pattern.argument, node);
+				break;
+		}
+	}
+
+	/**
+	 * Offers a written member expression to the `writeMemberChain` taps.
+	 * @param {MemberExpression} target the written member expression
+	 * @param {WriteStatement} node the construct performing the write
+	 * @returns {boolean} true when a tap rendered the write itself
+	 */
+	_callWriteMemberChain(target, node) {
+		return Boolean(
+			this._resolveMemberExpression(target, ALLOWED_MEMBER_TYPES_EXPRESSION) ===
+				1 &&
+			this._hasHooksForInfo(
+				this.hooks.writeMemberChain,
+				/** @type {string | VariableInfo} */ (this._memberRootInfo)
+			) &&
+			this.callHooksForInfo(
+				this.hooks.writeMemberChain,
+				/** @type {string | VariableInfo} */ (this._memberRootInfo),
+				node,
+				this._members
+			)
+		);
+	}
+
 	/**
 	 * Reports `arguments.callee` / `arguments.caller` — both throw a TypeError
 	 * once the module runs in strict-mode ESM output.
@@ -4418,6 +4956,7 @@ class JavascriptParser extends Parser {
 					this.defineVariable(name);
 				}
 			});
+			this._walkPatternWriteMembers(expression.left, expression);
 			this.walkPattern(expression.left);
 		} else if (expression.left.type === "MemberExpression") {
 			if (
@@ -4641,7 +5180,7 @@ class JavascriptParser extends Parser {
 		if (functionExpression.body.type === "BlockStatement") {
 			this.detectMode(functionExpression.body.body);
 			const prev = this.prevStatement;
-			this.preWalkStatement(functionExpression.body);
+			this._preWalkScope(functionExpression.body);
 			this.prevStatement = prev;
 			this.walkStatement(functionExpression.body);
 		} else {
@@ -4931,11 +5470,9 @@ class JavascriptParser extends Parser {
 		onUnhandled
 	) {
 		if (expression.object.type === "MemberExpression") {
-			// optimize the case where expression.object is a MemberExpression too.
-			// we can keep info here when calling walkMemberExpression directly
-			// Read the property from `members` (already extracted by
-			// extractMemberExpressionChain) since the AST node may be a
-			// TemplateLiteral, which has neither .name nor .value.
+			// A nested MemberExpression keeps its info by calling walkMemberExpression
+			// directly. The property comes from `members` rather than the node, which
+			// may be a TemplateLiteral and carry neither `.name` nor `.value`.
 			const property = members[members.length - 1];
 			name = name.slice(0, -property.length - 1);
 			members.pop();
@@ -5102,7 +5639,7 @@ class JavascriptParser extends Parser {
 		if (typeof info === "string") {
 			name = info;
 		} else {
-			if (!(info instanceof VariableInfo)) {
+			if (!JavascriptParser.isVariableInfo(info)) {
 				if (defined !== undefined) {
 					return defined();
 				}
@@ -5148,7 +5685,7 @@ class JavascriptParser extends Parser {
 	 */
 	_hasHooksForInfo(hookMap, info) {
 		if (typeof info === "string") return hookMap.get(info) !== undefined;
-		if (!(info instanceof VariableInfo)) return false;
+		if (!JavascriptParser.isVariableInfo(info)) return false;
 		let tagInfo = info.tagInfo;
 		while (tagInfo !== undefined) {
 			if (hookMap.get(tagInfo.tag) !== undefined) return true;
@@ -5212,7 +5749,7 @@ class JavascriptParser extends Parser {
 		if (typeof info === "string") {
 			name = info;
 		} else {
-			if (!(info instanceof VariableInfo)) {
+			if (!JavascriptParser.isVariableInfo(info)) {
 				return;
 			}
 			let tagInfo = info.tagInfo;
@@ -5389,6 +5926,37 @@ class JavascriptParser extends Parser {
 		return oldScope;
 	}
 
+	/**
+	 * The directive a statement spells, or `undefined` when it is not one. An
+	 * AST webpack did not parse may leave the metadata off a directive, so the
+	 * spelling is recovered from the literal itself there.
+	 * @param {Directive | Statement | ModuleDeclaration} statement statement
+	 * @returns {string | undefined} the spelling between the quotes
+	 */
+	getDirective(statement) {
+		if (statement.type !== "ExpressionStatement") return undefined;
+		const directive = /** @type {Directive} */ (statement).directive;
+		if (directive !== undefined || this._hasParserRecord) return directive;
+		const expression = statement.expression;
+		if (expression.type !== "Literal" || typeof expression.value !== "string") {
+			return undefined;
+		}
+		// a parenthesized string is an expression rather than a directive, and
+		// only the statement says so — the literal starts inside the parentheses
+		if (
+			statement.range !== undefined &&
+			expression.range !== undefined &&
+			statement.range[0] !== expression.range[0]
+		) {
+			return undefined;
+		}
+		// the raw text keeps an escape unexpanded, which is what separates a
+		// directive from a string that merely reads like one
+		return expression.raw === undefined
+			? expression.value
+			: expression.raw.slice(1, -1);
+	}
+
 	/**
 	 * Processes the provided statement.
 	 * @param {(Directive | Statement | ModuleDeclaration)[]} statements statements
@@ -5403,11 +5971,17 @@ class JavascriptParser extends Parser {
 			return;
 		}
 		const value = /** @type {Literal} */ (statement.expression).value;
-		if (value === "use strict") {
-			this.scope.isStrict = true;
-		} else if (value === "use asm") {
+		if (value === "use asm") {
 			this.scope.isAsmJs = true;
 		}
+		for (const directiveStatement of statements) {
+			const directive = this.getDirective(directiveStatement);
+			if (directive === undefined) break;
+			if (directive === "use strict") {
+				this.scope.isStrict = true;
+				break;
+			}
+		}
 	}
 
 	/**
@@ -5716,6 +6290,13 @@ class JavascriptParser extends Parser {
 		const oldStrictInModuleOutput = this._strictInModuleOutput;
 		const oldSource = this._source;
 		const oldLineStarts = this._lineStarts;
+		const oldHasParserRecord = this._hasParserRecord;
+		// WHY: the parser's record of each scope is only the truth for a tree it
+		// just built. A loader's AST, and whatever `module.parser.javascript.parse`
+		// returns, may have been edited after it was read — or built by something
+		// else entirely — so both are collected from instead of trusted.
+		this._hasParserRecord =
+			typeof source !== "object" && typeof this.options.parse !== "function";
 		// a preparsed AST carries no text, but the build passes the module
 		// source in the state — offsets still map for it
 		this._source =
@@ -5763,11 +6344,13 @@ class JavascriptParser extends Parser {
 			if (this._strictInModuleOutput && this.scope.isStrict) {
 				this._strictInModuleOutput = false;
 			}
-			this.modulePreWalkStatements(ast.body);
+			this._modulePreWalkDeclarations(
+				moduleDeclarationsOf(ast, this._hasParserRecord)
+			);
 			this.prevStatement = undefined;
-			this.preWalkStatements(ast.body);
+			this._preWalkScope(ast);
 			this.prevStatement = undefined;
-			this.blockPreWalkStatements(ast.body);
+			this._blockPreWalkScope(ast, ast.body);
 			this.prevStatement = undefined;
 			this.walkStatements(ast.body);
 			this.destructuringAssignmentProperties = undefined;
@@ -5784,6 +6367,7 @@ class JavascriptParser extends Parser {
 		// release — these retain the whole source string and its line table
 		this._source = oldSource;
 		this._lineStarts = oldLineStarts;
+		this._hasParserRecord = oldHasParserRecord;
 		return state;
 	}
 
@@ -5902,10 +6486,9 @@ class JavascriptParser extends Parser {
 				});
 			}
 			case "TemplateLiteral":
-				// 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.
+				// Thread `commentsStartPos` through the interpolations, so a
+				// `/*#__PURE__*/` inside `${ … }`, or before the first one, is within
+				// the range scanned when the inner expression's purity is judged.
 				return expr.expressions.every((e) => {
 					const pureFlag = this.isPure(e, commentsStartPos);
 					commentsStartPos = /** @type {Range} */ (e.range)[1];
@@ -5959,17 +6542,13 @@ class JavascriptParser extends Parser {
 				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`).
+				// WHY: these three produce their result without invoking user code on
+				// the operand. `typeof` returns a type tag and never throws, even for an
+				// undeclared identifier, and coerces nothing; `void` evaluates the
+				// operand and discards it, so it is pure exactly when the operand is; and
+				// `!` coerces through ToBoolean, which is defined to call no user code.
+				// `+`, `-`, `~` and `delete` fall through to the generic evaluator, which
+				// still recognizes literal cases such as `-1` and `+5`.
 				if (
 					expr.operator === "typeof" ||
 					expr.operator === "void" ||
@@ -5983,12 +6562,12 @@ class JavascriptParser extends Parser {
 				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.
+				// WHY: strict (in)equality compares without coercion and never invokes user
+				// code on its operands, so the result is pure where both sides are. Every
+				// other binary operator may invoke `valueOf`, `toString`,
+				// `[Symbol.hasInstance]` or a Proxy trap, and falls through to the generic
+				// evaluator, which still recognizes the cases where both sides evaluate
+				// to known primitive literals.
 				if (expr.operator === "===" || expr.operator === "!==") {
 					return (
 						this.isPure(expr.left, commentsStartPos) &&
@@ -6145,6 +6724,50 @@ class JavascriptParser extends Parser {
 		);
 	}
 
+	/**
+	 * Where the comments written for `statement` begin: the run of comments
+	 * before it that whitespace alone separates from it and from each other.
+	 * @param {StatementPathItem} statement the statement they belong to
+	 * @returns {number} the offset the run starts at, or the statement's own
+	 */
+	getAttachedCommentsStart(statement) {
+		let position = /** @type {Range} */ (statement.range)[0];
+		// what precedes `export function f() {}` is written for the export, and
+		// the export keyword is the token the run would otherwise stop at
+		const path = this.statementPath;
+		if (path !== undefined && path.length > 1) {
+			const outer = path[path.length - 2];
+			if (
+				(outer.type === "ExportNamedDeclaration" ||
+					outer.type === "ExportDefaultDeclaration") &&
+				outer.declaration === statement
+			) {
+				position = /** @type {Range} */ (outer.range)[0];
+			}
+		}
+		const comments = this.comments;
+		if (comments === undefined) return position;
+		const source = this._source;
+		for (
+			let index = binarySearchBounds.le(comments, position, compareCommentEnd);
+			index >= 0;
+			index--
+		) {
+			const range = /** @type {Range} */ (comments[index].range);
+			if (range[1] > position) continue;
+			// with no source to read, nothing can be ruled out, so the run is
+			// taken to reach as far as the comments themselves do
+			if (
+				source !== undefined &&
+				!onlyWhitespaceBetween(source, range[1], position)
+			) {
+				break;
+			}
+			position = range[0];
+		}
+		return position;
+	}
+
 	/**
 	 * Reports whether `identifier` may occur as a word in the source text of
 	 * `range`. A conservative pre-filter for expensive AST scans: `false` means
@@ -6327,7 +6950,7 @@ class JavascriptParser extends Parser {
 	 */
 	getTagData(name, tag) {
 		const info = this.scope.definitions.get(name);
-		if (info instanceof VariableInfo) {
+		if (JavascriptParser.isVariableInfo(info)) {
 			let tagInfo = info.tagInfo;
 			while (tagInfo !== undefined) {
 				if (tagInfo.tag === tag) return tagInfo.data;
@@ -6353,7 +6976,7 @@ class JavascriptParser extends Parser {
 				data,
 				next: undefined
 			});
-		} else if (oldInfo instanceof VariableInfo) {
+		} else if (JavascriptParser.isVariableInfo(oldInfo)) {
 			newInfo = new VariableInfo(
 				oldInfo.declaredScope,
 				oldInfo.name,
@@ -6383,7 +7006,7 @@ class JavascriptParser extends Parser {
 		const oldInfo = this.scope.definitions.get(name);
 		// Don't redefine variable in same scope to keep existing tags
 		if (
-			oldInfo instanceof VariableInfo &&
+			JavascriptParser.isVariableInfo(oldInfo) &&
 			oldInfo.declaredScope === this.scope
 		) {
 			return;
@@ -6409,7 +7032,7 @@ class JavascriptParser extends Parser {
 	isVariableDefined(name) {
 		const info = this.scope.definitions.get(name);
 		if (info === undefined) return false;
-		if (info instanceof VariableInfo) {
+		if (JavascriptParser.isVariableInfo(info)) {
 			return !info.isFree();
 		}
 		return true;
@@ -6425,7 +7048,7 @@ class JavascriptParser extends Parser {
 	_isDefinedPlainVariable(name) {
 		const info = this.scope.definitions.get(name);
 		if (info === undefined) return false;
-		if (info instanceof VariableInfo) {
+		if (JavascriptParser.isVariableInfo(info)) {
 			return !(info.isFree() || info.isTagged() || info.tagInfo !== undefined);
 		}
 		return true;
@@ -6488,7 +7111,7 @@ 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
+	 * @returns {{ options: MagicCommentOptions | null, errors: (Error & { comment: Comment })[] | null }} result
 	 */
 	parseCommentOptions(range) {
 		return parseCommentOptionsInRange(
@@ -6588,7 +7211,7 @@ class JavascriptParser extends Parser {
 		const info = this.getVariableInfo(varName);
 		/** @type {string} */
 		let name;
-		if (info instanceof VariableInfo && info.name) {
+		if (JavascriptParser.isVariableInfo(info) && info.name) {
 			if (!info.isFree()) return;
 			name = info.name;
 		} else if (typeof info !== "string") {
@@ -6608,7 +7231,7 @@ class JavascriptParser extends Parser {
 		const info = this.getVariableInfo(varName);
 		/** @type {string} */
 		let name;
-		if (info instanceof VariableInfo && info.name) {
+		if (JavascriptParser.isVariableInfo(info) && info.name) {
 			if (!info.isFree() && !info.isTagged()) return;
 			name = info.name;
 		} else if (typeof info !== "string") {
@@ -6719,7 +7342,7 @@ class JavascriptParser extends Parser {
 	 */
 	_resolveMemberRoot(rootName) {
 		const info = this.getVariableInfo(rootName);
-		if (info instanceof VariableInfo && info.name) {
+		if (JavascriptParser.isVariableInfo(info) && info.name) {
 			if (!info.isFree() && !info.isTagged()) return;
 			this._memberRootInfo = info;
 			return info.name;
@@ -6850,6 +7473,15 @@ class JavascriptParser extends Parser {
 		);
 	}
 
+	/**
+	 * Whether a definition is a variable rather than a free name or a scope.
+	 * @param {unknown} value a scope definition
+	 * @returns {value is VariableInfo} true when the value is a variable
+	 */
+	static isVariableInfo(value) {
+		return value instanceof VariableInfo;
+	}
+
 	/**
 	 * Get module parse function.
 	 * @param {Compilation} compilation compilation
@@ -6858,10 +7490,7 @@ class JavascriptParser extends Parser {
 	 */
 	static _getModuleParseFunction(compilation, module) {
 		// Get from module if available
-		if (
-			module instanceof NormalModule &&
-			module.parser instanceof JavascriptParser
-		) {
+		if (module.is("normal") && module.parser instanceof JavascriptParser) {
 			return module.parser.options.parse;
 		}