webpack 5.111.0 → 5.111.1

package/lib/javascript/JavascriptParser.js

@@ -17,12 +17,19 @@ const {
 	parseCommentOptionsInRange
 } = require("../util/magicComment");
 const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
+const { nonASCIIwhitespace } = require("./parser");
 const {
+	BLOCK_DECLARATIONS,
+	HOISTED_DECLARATIONS,
 	LEGACY_ASSERT_ATTRIBUTES,
+	MAX_MASKED_INDEX,
+	MODULE_DECLARATIONS,
 	WebpackParser,
 	buildLineStarts,
+	declaresIntoBlock,
 	hasOctalEscape,
 	isIdentifierChar,
+	overflowFrom,
 	positionAt
 } = require("./syntax");
 
@@ -137,6 +144,9 @@ const {
 /** @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 +155,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 = [];
 
@@ -354,6 +390,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 */
 
@@ -922,6 +959,183 @@ 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 {EXPECTED_ANY} */ (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 {EXPECTED_ANY} */ (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;
+};
+
+/**
+ * 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 +1198,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 webpack 6: 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 webpack 6.
 			 * @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 webpack 6: 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 webpack 6.
 			 * @type {HookMap<SyncBailHook<[Statement | ModuleDeclaration | MaybeNamedClassDeclaration | MaybeNamedFunctionDeclaration], boolean | void>>}
 			 * @since 5.109.0
 			 */
@@ -1092,6 +1322,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 +1437,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} */
@@ -2378,12 +2645,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 +2678,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 webpack 6: 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 webpack 6: remove, with the `preStatement` hook
+	 */
+	preWalkBlockStatement(statement) {
+		this.preWalkStatements(statement.body);
+	}
+
+	/**
+	 * Pre walk if statement.
+	 * @param {IfStatement} statement if statement
+	 * @deprecated TODO webpack 6: 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 webpack 6: remove, with the `preStatement` hook
+	 */
+	preWalkLabeledStatement(statement) {
+		this.preWalkStatement(statement.body);
+	}
+
+	/**
+	 * Pre walk with statement.
+	 * @param {WithStatement} statement with statement
+	 * @deprecated TODO webpack 6: remove, with the `preStatement` hook
+	 */
+	preWalkWithStatement(statement) {
+		this.preWalkStatement(statement.body);
+	}
+
+	/**
+	 * Pre walk switch statement.
+	 * @param {SwitchStatement} statement switch statement
+	 * @deprecated TODO webpack 6: remove, with the `preStatement` hook
+	 */
+	preWalkSwitchStatement(statement) {
+		this.preWalkSwitchCases(statement.cases);
+	}
+
+	/**
+	 * Pre walk switch cases.
+	 * @param {SwitchCase[]} switchCases switch cases
+	 * @deprecated TODO webpack 6: 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 webpack 6: 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 webpack 6: remove, with the `preStatement` hook
+	 */
+	preWalkCatchClause(catchClause) {
+		this.preWalkStatement(catchClause.body);
+	}
+
+	/**
+	 * Pre walk while statement.
+	 * @param {WhileStatement} statement while statement
+	 * @deprecated TODO webpack 6: remove, with the `preStatement` hook
+	 */
+	preWalkWhileStatement(statement) {
+		this.preWalkStatement(statement.body);
+	}
+
+	/**
+	 * Pre walk do while statement.
+	 * @param {DoWhileStatement} statement do while statement
+	 * @deprecated TODO webpack 6: remove, with the `preStatement` hook
+	 */
+	preWalkDoWhileStatement(statement) {
+		this.preWalkStatement(statement.body);
+	}
+
+	/**
+	 * Pre walk for statement.
+	 * @param {ForStatement} statement for statement
+	 * @deprecated TODO webpack 6: 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 webpack 6: 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 webpack 6: 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 webpack 6: 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 webpack 6: remove, with the `blockPreStatement` hook
 	 */
 	blockPreWalkStatements(statements) {
 		for (let index = 0, len = statements.length; index < len; index++) {
@@ -2424,6 +2891,68 @@ 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 {EXPECTED_ANY} */ (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 +3002,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 +3190,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 +3199,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,17 +3214,6 @@ 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.
@@ -2768,14 +3280,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 +3296,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 +3314,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 +3355,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 +3393,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 +3405,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 +3417,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 +3444,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 +3454,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 +3463,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 +3474,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 +3484,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 +3507,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 +3549,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 +4127,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 +4142,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 +4163,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 +4491,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 +4516,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 +4577,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 +4917,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 +5141,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 +5431,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();
@@ -5716,6 +6214,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 +6268,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 +6291,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 +6410,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 +6466,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 +6486,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 +6648,46 @@ 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 = comments.length - 1; 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