@depup/webpack 5.110.3-depup.0 → 5.111.1-depup.0

package/lib/javascript/JavascriptParser.js

@@ -17,22 +17,23 @@ 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");
 
-/** @typedef {typeof import("acorn").Parser} AcornParser */
-/**
- * @import {
- * 	Options as AcornOptions,
- * 	ecmaVersion as EcmaVersion
- * } from "acorn"
- */
+/** @import { EcmaVersion, ParserOptions, ParserPlugin } from "./syntax" */
 /**
  * @import {
  * 	AssignmentExpression,
@@ -143,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 */
 
@@ -151,25 +155,34 @@ 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"
+]);
 
-/**
- * Getter that reverses `arr` in place on first access and caches it. Lighter
- * than `memoize(() => arr.reverse())` (one closure instead of two) and called
- * per member expression on hot parse paths.
- * @template T
- * @param {T[]} arr array reversed lazily on first access
- * @returns {() => T[]} getter returning the reversed array
- */
-const lazyReverse = (arr) => {
-	let reversed = false;
-	return () => {
-		if (!reversed) {
-			arr.reverse();
-			reversed = true;
-		}
-		return arr;
-	};
-};
+/** @type {MembersOptionals} */
+const EMPTY_MEMBERS_OPTIONALS = [];
 
 const ALLOWED_MEMBER_TYPES_CALL_EXPRESSION = 0b01;
 const ALLOWED_MEMBER_TYPES_EXPRESSION = 0b10;
@@ -183,8 +196,11 @@ const RETURN_FALSE = () => false;
 // replacing three fresh closures per evaluated free variable.
 const RETURN_EMPTY_ARRAY = () => [];
 
+// Shared no-result fallback for the identifier evaluators.
+const RETURN_UNDEFINED = () => undefined;
+
 // Syntax: https://developer.mozilla.org/en/SpiderMonkey/Parser_API
-let parser = /** @type {AcornParser} */ (WebpackParser);
+let parser = WebpackParser;
 
 /** @typedef {Record<string, string> & { _isLegacyAssert?: boolean }} ImportAttributes */
 
@@ -327,7 +343,7 @@ class VariableInfo {
  * @property {boolean=} ranges
  * @property {boolean=} allowHashBang
  * @property {boolean=} allowReturnOutsideFunction
- * @property {boolean=} lazyNodes internal: serve `range` lazily and skip acorn's location/range tracking
+ * @property {boolean=} lazyNodes internal: serve `range` lazily and skip the parser's location/range tracking
  * @property {Comment[]=} lazyComments internal: collect comments here without slicing their text eagerly
  * @property {boolean=} importPhases enable parsing of the import phase proposals (import defer / import source)
  * @property {boolean=} moduleFallback internal: for `auto`, let the parser downgrade module->script in place instead of re-parsing
@@ -374,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 */
 
@@ -430,24 +447,455 @@ const joinRanges = (startRange, endRange) => {
  * Helper function used to generate a string representation of a
  * [member expression](https://github.com/estree/estree/blob/master/es5.md#memberexpression).
  * @param {string} object object to name
- * @param {Members} membersReversed reversed list of members
+ * @param {Members} members members in source order
  * @returns {string} member expression as a string
  * @example
  * ```js
- * const membersReversed = ["property1", "property2", "property3"]; // Members parsed from the AST
- * const name = objectAndMembersToName("myObject", membersReversed);
+ * const members = ["property1", "property2", "property3"]; // Members parsed from the AST
+ * const name = objectAndMembersToName("myObject", members);
  *
  * console.log(name); // "myObject.property1.property2.property3"
  * ```
  */
-const objectAndMembersToName = (object, membersReversed) => {
+const objectAndMembersToName = (object, members) => {
 	let name = object;
-	for (let i = membersReversed.length - 1; i >= 0; i--) {
-		name = `${name}.${membersReversed[i]}`;
+	for (let i = 0; i < members.length; i++) {
+		name = `${name}.${members[i]}`;
 	}
 	return name;
 };
 
+/**
+ * The range of the object below each of the first `count` members of a chain,
+ * in source order: what `extractMemberExpressionChain` reports as memberRanges.
+ * @param {Expression | Super} expression a member expression
+ * @param {number} count how many members the chain has
+ * @returns {MemberRanges} the ranges
+ */
+const memberRangesOf = (expression, count) => {
+	/** @type {MemberRanges} */
+	const ranges = [];
+	let expr = /** @type {MemberExpression} */ (expression);
+	for (let i = 0; i < count; i++) {
+		const object = expr.object;
+		ranges.push(/** @type {Range} */ (object.range));
+		expr = /** @type {MemberExpression} */ (object);
+	}
+	if (count > 1) ranges.reverse();
+	return ranges;
+};
+
+/**
+ * In simple logical cases, we can use valueAsExpression to assist us in evaluating the expression on
+ * either side of a [BinaryExpression](https://github.com/estree/estree/blob/master/es5.md#binaryexpression).
+ * This supports scenarios in webpack like conditionally `import()`'ing modules based on some simple evaluation:
+ *
+ * ```js
+ * if (1 === 3) {
+ *  import("./moduleA"); // webpack will auto evaluate this and not import the modules
+ * }
+ * ```
+ *
+ * Additional scenarios include evaluation of strings inside of dynamic import statements:
+ *
+ * ```js
+ * const foo = "foo";
+ * const bar = "bar";
+ *
+ * import("./" + foo + bar); // webpack will auto evaluate this into import("./foobar")
+ * ```
+ * @param {boolean | number | bigint | string} value the value to convert to an expression
+ * @param {BinaryExpression | UnaryExpression} expr the expression being evaluated
+ * @param {boolean} sideEffects whether the expression has side effects
+ * @returns {BasicEvaluatedExpression | undefined} the evaluated expression
+ * @example
+ *
+ * ```js
+ * const binaryExpr = new BinaryExpression("+",
+ * 	{ type: "Literal", value: 2 },
+ * 	{ type: "Literal", value: 3 }
+ * );
+ *
+ * const leftValue = 2;
+ * const rightValue = 3;
+ *
+ * const leftExpr = valueAsExpression(leftValue, binaryExpr.left, false);
+ * const rightExpr = valueAsExpression(rightValue, binaryExpr.right, false);
+ * const result = new BasicEvaluatedExpression()
+ * 	.setNumber(leftExpr.number + rightExpr.number)
+ * 	.setRange(binaryExpr.range);
+ *
+ * console.log(result.number); // Output: 5
+ * ```
+ */
+const valueAsExpression = (value, expr, sideEffects) => {
+	switch (typeof value) {
+		case "boolean":
+			return new BasicEvaluatedExpression()
+				.setBoolean(value)
+				.setSideEffects(sideEffects)
+				.setRange(/** @type {Range} */ (expr.range));
+		case "number":
+			return new BasicEvaluatedExpression()
+				.setNumber(value)
+				.setSideEffects(sideEffects)
+				.setRange(/** @type {Range} */ (expr.range));
+		case "bigint":
+			return new BasicEvaluatedExpression()
+				.setBigInt(value)
+				.setSideEffects(sideEffects)
+				.setRange(/** @type {Range} */ (expr.range));
+		case "string":
+			return new BasicEvaluatedExpression()
+				.setString(value)
+				.setSideEffects(sideEffects)
+				.setRange(/** @type {Range} */ (expr.range));
+	}
+};
+
+// The constant operators, shared so evaluating `a - b` allocates no handler.
+
+/**
+ * @param {EXPECTED_ANY} l left operand
+ * @param {EXPECTED_ANY} r right operand
+ * @returns {EXPECTED_ANY} the result
+ */
+const SUBTRACT = (l, r) => l - r;
+
+/**
+ * @param {EXPECTED_ANY} l left operand
+ * @param {EXPECTED_ANY} r right operand
+ * @returns {EXPECTED_ANY} the result
+ */
+const MULTIPLY = (l, r) => l * r;
+
+/**
+ * @param {EXPECTED_ANY} l left operand
+ * @param {EXPECTED_ANY} r right operand
+ * @returns {EXPECTED_ANY} the result
+ */
+const DIVIDE = (l, r) => l / r;
+
+/**
+ * @param {EXPECTED_ANY} l left operand
+ * @param {EXPECTED_ANY} r right operand
+ * @returns {EXPECTED_ANY} the result
+ */
+const POWER = (l, r) => l ** r;
+
+/**
+ * @param {EXPECTED_ANY} l left operand
+ * @param {EXPECTED_ANY} r right operand
+ * @returns {EXPECTED_ANY} the result
+ */
+const BITWISE_AND = (l, r) => l & r;
+
+/**
+ * @param {EXPECTED_ANY} l left operand
+ * @param {EXPECTED_ANY} r right operand
+ * @returns {EXPECTED_ANY} the result
+ */
+const BITWISE_OR = (l, r) => l | r;
+
+/**
+ * @param {EXPECTED_ANY} l left operand
+ * @param {EXPECTED_ANY} r right operand
+ * @returns {EXPECTED_ANY} the result
+ */
+const BITWISE_XOR = (l, r) => l ^ r;
+
+/**
+ * @param {EXPECTED_ANY} l left operand
+ * @param {EXPECTED_ANY} r right operand
+ * @returns {EXPECTED_ANY} the result
+ */
+const UNSIGNED_SHIFT_RIGHT = (l, r) => l >>> r;
+
+/**
+ * @param {EXPECTED_ANY} l left operand
+ * @param {EXPECTED_ANY} r right operand
+ * @returns {EXPECTED_ANY} the result
+ */
+const SHIFT_RIGHT = (l, r) => l >> r;
+
+/**
+ * @param {EXPECTED_ANY} l left operand
+ * @param {EXPECTED_ANY} r right operand
+ * @returns {EXPECTED_ANY} the result
+ */
+const SHIFT_LEFT = (l, r) => l << r;
+
+/**
+ * @param {EXPECTED_ANY} l left operand
+ * @param {EXPECTED_ANY} r right operand
+ * @returns {EXPECTED_ANY} the result
+ */
+const LESS_THAN = (l, r) => l < r;
+
+/**
+ * @param {EXPECTED_ANY} l left operand
+ * @param {EXPECTED_ANY} r right operand
+ * @returns {EXPECTED_ANY} the result
+ */
+const GREATER_THAN = (l, r) => l > r;
+
+/**
+ * @param {EXPECTED_ANY} l left operand
+ * @param {EXPECTED_ANY} r right operand
+ * @returns {EXPECTED_ANY} the result
+ */
+const LESS_THAN_OR_EQUAL = (l, r) => l <= r;
+
+/**
+ * @param {EXPECTED_ANY} l left operand
+ * @param {EXPECTED_ANY} r right operand
+ * @returns {EXPECTED_ANY} the result
+ */
+const GREATER_THAN_OR_EQUAL = (l, r) => l >= r;
+
+/**
+ * @param {EXPECTED_ANY} v operand
+ * @returns {EXPECTED_ANY} the result
+ */
+const BITWISE_NOT = (v) => ~v;
+
+/**
+ * @param {EXPECTED_ANY} v operand
+ * @returns {EXPECTED_ANY} the result
+ */
+// eslint-disable-next-line no-implicit-coercion
+const TO_NUMBER = (v) => +v;
+
+/**
+ * @param {EXPECTED_ANY} v operand
+ * @returns {EXPECTED_ANY} the result
+ */
+const NEGATE = (v) => -v;
+
+/**
+ * Evaluates a binary expression if and only if it is a const operation (e.g. 1 + 2, "a" + "b", etc.).
+ * @template T
+ * @param {JavascriptParser} parser the parser evaluating the expression
+ * @param {BinaryExpression} expr the binary expression
+ * @param {(leftOperand: T, rightOperand: T) => boolean | number | bigint | string} operandHandler the handler for the operation (e.g. (a, b) => a + b)
+ * @returns {BasicEvaluatedExpression | undefined} the evaluated expression
+ */
+const handleConstOperation = (parser, expr, operandHandler) => {
+	const left = parser.evaluateExpression(expr.left);
+	if (!left.isCompileTimeValue()) return;
+
+	const right = parser.evaluateExpression(expr.right);
+	if (!right.isCompileTimeValue()) return;
+
+	const result = operandHandler(
+		/** @type {T} */ (left.asCompileTimeValue()),
+		/** @type {T} */ (right.asCompileTimeValue())
+	);
+	return valueAsExpression(
+		result,
+		expr,
+		left.couldHaveSideEffects() || right.couldHaveSideEffects()
+	);
+};
+
+/**
+ * Helper function to determine if two booleans are always different. This is used in `handleStrictEqualityComparison`
+ * to determine if an expressions boolean or nullish conversion is equal or not.
+ * @param {boolean} a first boolean to compare
+ * @param {boolean} b second boolean to compare
+ * @returns {boolean} true if the two booleans are always different, false otherwise
+ */
+const isAlwaysDifferent = (a, b) =>
+	(a === true && b === false) || (a === false && b === true);
+
+/**
+ * Handle template string compare.
+ * @param {BasicEvaluatedExpression} left left
+ * @param {BasicEvaluatedExpression} right right
+ * @param {BinaryExpression} expr the comparison, for its range
+ * @param {boolean} eql true for "===" and false for "!=="
+ * @returns {BasicEvaluatedExpression | undefined} result
+ */
+const handleTemplateStringCompare = (left, right, expr, eql) => {
+	/**
+	 * Returns value.
+	 * @param {BasicEvaluatedExpression[]} parts parts
+	 * @returns {string} value
+	 */
+	const getPrefix = (parts) => {
+		let value = "";
+		for (const p of parts) {
+			const v = p.asString();
+			if (v !== undefined) value += v;
+			else break;
+		}
+		return value;
+	};
+	/**
+	 * Returns value.
+	 * @param {BasicEvaluatedExpression[]} parts parts
+	 * @returns {string} value
+	 */
+	const getSuffix = (parts) => {
+		let value = "";
+		for (let i = parts.length - 1; i >= 0; i--) {
+			const v = parts[i].asString();
+			if (v !== undefined) value = v + value;
+			else break;
+		}
+		return value;
+	};
+	const leftPrefix = getPrefix(
+		/** @type {BasicEvaluatedExpression[]} */ (left.parts)
+	);
+	const rightPrefix = getPrefix(
+		/** @type {BasicEvaluatedExpression[]} */ (right.parts)
+	);
+	const leftSuffix = getSuffix(
+		/** @type {BasicEvaluatedExpression[]} */ (left.parts)
+	);
+	const rightSuffix = getSuffix(
+		/** @type {BasicEvaluatedExpression[]} */ (right.parts)
+	);
+	const lenPrefix = Math.min(leftPrefix.length, rightPrefix.length);
+	const lenSuffix = Math.min(leftSuffix.length, rightSuffix.length);
+	const prefixMismatch =
+		lenPrefix > 0 &&
+		leftPrefix.slice(0, lenPrefix) !== rightPrefix.slice(0, lenPrefix);
+	const suffixMismatch =
+		lenSuffix > 0 &&
+		leftSuffix.slice(-lenSuffix) !== rightSuffix.slice(-lenSuffix);
+	if (prefixMismatch || suffixMismatch) {
+		return new BasicEvaluatedExpression()
+			.setRange(/** @type {Range} */ (expr.range))
+			.setBoolean(!eql)
+			.setSideEffects(
+				left.couldHaveSideEffects() || right.couldHaveSideEffects()
+			);
+	}
+};
+
+/**
+ * Helper function to handle BinaryExpressions using strict equality comparisons (e.g. "===" and "!==").
+ * @param {JavascriptParser} parser the parser evaluating the expression
+ * @param {BinaryExpression} expr the binary expression
+ * @param {boolean} eql true for "===" and false for "!=="
+ * @returns {BasicEvaluatedExpression | undefined} the evaluated expression
+ */
+const handleStrictEqualityComparison = (parser, expr, eql) => {
+	const left = parser.evaluateExpression(expr.left);
+	const right = parser.evaluateExpression(expr.right);
+
+	const leftConst = left.isCompileTimeValue();
+	const rightConst = right.isCompileTimeValue();
+
+	if (leftConst && rightConst) {
+		return new BasicEvaluatedExpression()
+			.setRange(/** @type {Range} */ (expr.range))
+			.setBoolean(
+				eql === (left.asCompileTimeValue() === right.asCompileTimeValue())
+			)
+			.setSideEffects(
+				left.couldHaveSideEffects() || right.couldHaveSideEffects()
+			);
+	}
+
+	if (left.isArray() && right.isArray()) {
+		return new BasicEvaluatedExpression()
+			.setRange(/** @type {Range} */ (expr.range))
+			.setBoolean(!eql)
+			.setSideEffects(
+				left.couldHaveSideEffects() || right.couldHaveSideEffects()
+			);
+	}
+	if (left.isTemplateString() && right.isTemplateString()) {
+		return handleTemplateStringCompare(left, right, expr, eql);
+	}
+
+	const leftPrimitive = left.isPrimitiveType();
+	const rightPrimitive = right.isPrimitiveType();
+
+	if (
+		// Primitive !== Object or
+		// compile-time object types are never equal to something at runtime
+		(leftPrimitive === false && (leftConst || rightPrimitive === true)) ||
+		(rightPrimitive === false && (rightConst || leftPrimitive === true)) ||
+		// Different nullish or boolish status also means not equal
+		isAlwaysDifferent(
+			/** @type {boolean} */ (left.asBool()),
+			/** @type {boolean} */ (right.asBool())
+		) ||
+		isAlwaysDifferent(
+			/** @type {boolean} */ (left.asNullish()),
+			/** @type {boolean} */ (right.asNullish())
+		)
+	) {
+		return new BasicEvaluatedExpression()
+			.setRange(/** @type {Range} */ (expr.range))
+			.setBoolean(!eql)
+			.setSideEffects(
+				left.couldHaveSideEffects() || right.couldHaveSideEffects()
+			);
+	}
+};
+
+/**
+ * Helper function to handle BinaryExpressions using abstract equality comparisons (e.g. "==" and "!=").
+ * @param {JavascriptParser} parser the parser evaluating the expression
+ * @param {BinaryExpression} expr the binary expression
+ * @param {boolean} eql true for "==" and false for "!="
+ * @returns {BasicEvaluatedExpression | undefined} the evaluated expression
+ */
+const handleAbstractEqualityComparison = (parser, expr, eql) => {
+	const left = parser.evaluateExpression(expr.left);
+	const right = parser.evaluateExpression(expr.right);
+
+	const leftConst = left.isCompileTimeValue();
+	const rightConst = right.isCompileTimeValue();
+
+	if (leftConst && rightConst) {
+		return new BasicEvaluatedExpression()
+			.setRange(/** @type {Range} */ (expr.range))
+			.setBoolean(
+				eql ===
+					// eslint-disable-next-line eqeqeq
+					(left.asCompileTimeValue() == right.asCompileTimeValue())
+			)
+			.setSideEffects(
+				left.couldHaveSideEffects() || right.couldHaveSideEffects()
+			);
+	}
+
+	if (left.isArray() && right.isArray()) {
+		return new BasicEvaluatedExpression()
+			.setRange(/** @type {Range} */ (expr.range))
+			.setBoolean(!eql)
+			.setSideEffects(
+				left.couldHaveSideEffects() || right.couldHaveSideEffects()
+			);
+	}
+	if (left.isTemplateString() && right.isTemplateString()) {
+		return handleTemplateStringCompare(left, right, expr, eql);
+	}
+};
+
+/**
+ * Evaluates a UnaryExpression if and only if it is a basic const operator (e.g. +a, -a, ~a).
+ * @template T
+ * @param {JavascriptParser} parser the parser evaluating the expression
+ * @param {UnaryExpression} expr the unary expression
+ * @param {(operand: T) => boolean | number | bigint | string} operandHandler handler for the operand
+ * @returns {BasicEvaluatedExpression | undefined} evaluated expression
+ */
+const handleUnaryConstOperation = (parser, expr, operandHandler) => {
+	const argument = parser.evaluateExpression(expr.argument);
+	if (!argument.isCompileTimeValue()) return;
+	const result = operandHandler(
+		/** @type {T} */ (argument.asCompileTimeValue())
+	);
+	return valueAsExpression(result, expr, argument.couldHaveSideEffects());
+};
+
 /**
  * Grabs the name of a given expression and returns it as a string or undefined. Has particular
  * handling for [Identifiers](https://github.com/estree/estree/blob/master/es5.md#identifier),
@@ -511,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).
@@ -573,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
 			 */
@@ -681,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"])
@@ -790,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} */
@@ -802,6 +1480,32 @@ class JavascriptParser extends Parser {
 		// Offset of each line's first character, built on first getLocation use.
 		/** @type {number[] | undefined} */
 		this._lineStarts = undefined;
+		// The last member expression resolved, kept while the node and the scope
+		// it resolved in stay the same: the walk and an evaluate of one node meet
+		/** @type {Expression | Super | undefined} */
+		this._memberExpression = undefined;
+		/** @type {ScopeInfo | undefined} */
+		this._memberScope = undefined;
+		/** @type {number} */
+		this._memberMask = 0;
+		/** @type {0 | 1 | 2} */
+		this._memberType = 0;
+		/** @type {string} */
+		this._memberName = "";
+		/** @type {string | VariableInfo | undefined} */
+		this._memberRootInfo = undefined;
+		/** @type {Members} */
+		this._members = EMPTY_ARRAY;
+		/** @type {MembersOptionals} */
+		this._membersOptionals = EMPTY_MEMBERS_OPTIONALS;
+		/** @type {CallExpression | undefined} */
+		this._memberCall = undefined;
+		/** @type {string} */
+		this._memberCalleeName = "";
+		/** @type {CalleeMembers} */
+		this._memberCalleeMembers = EMPTY_ARRAY;
+		/** @type {CallExpressionInfo | ExpressionExpressionInfo | undefined} */
+		this._memberInfo = undefined;
 		// True while only the parser's own taps sit on evaluate.for("Identifier");
 		// recomputed per parse, gates the defined-identifier fast paths.
 		this._evalIdentOwnTaps = false;
@@ -809,6 +1513,22 @@ class JavascriptParser extends Parser {
 		// Reused for enterPatterns on every scope entry to avoid per-scope closures.
 		/** @type {OnIdentString} */
 		this._defineVariable = (ident) => this.defineVariable(ident);
+		// The expression an identifier evaluator is running for, read by the
+		// shared `_evaluateDefinedIdentifier` instead of a closure per evaluation
+		/** @type {Identifier | ThisExpression | MemberExpression | undefined} */
+		this._evaluatingExpression = undefined;
+		/** @type {(name?: string) => BasicEvaluatedExpression | null | undefined} */
+		this._evaluateDefinedIdentifier = (name) => {
+			const hook = this.hooks.evaluateDefinedIdentifier.get(
+				/** @type {string} */ (name)
+			);
+			if (hook !== undefined) {
+				return hook.call(
+					/** @type {Identifier | ThisExpression | MemberExpression} */
+					(this._evaluatingExpression)
+				);
+			}
+		};
 		this._initializeEvaluating();
 		// keyed taps are free for every other member chain, and a shadowed
 		// `arguments` binding never dispatches the free-variable hooks
@@ -867,7 +1587,7 @@ class JavascriptParser extends Parser {
 			const callee = expr.callee;
 			if (callee.type !== "Identifier") return;
 			if (callee.name !== "RegExp") {
-				return this.callHooksForName(
+				return this._callHooksForName1(
 					this.hooks.evaluateNewExpression,
 					callee.name,
 					expr
@@ -979,278 +1699,10 @@ class JavascriptParser extends Parser {
 			}
 		});
 
-		/**
-		 * In simple logical cases, we can use valueAsExpression to assist us in evaluating the expression on
-		 * either side of a [BinaryExpression](https://github.com/estree/estree/blob/master/es5.md#binaryexpression).
-		 * This supports scenarios in webpack like conditionally `import()`'ing modules based on some simple evaluation:
-		 *
-		 * ```js
-		 * if (1 === 3) {
-		 *  import("./moduleA"); // webpack will auto evaluate this and not import the modules
-		 * }
-		 * ```
-		 *
-		 * Additional scenarios include evaluation of strings inside of dynamic import statements:
-		 *
-		 * ```js
-		 * const foo = "foo";
-		 * const bar = "bar";
-		 *
-		 * import("./" + foo + bar); // webpack will auto evaluate this into import("./foobar")
-		 * ```
-		 * @param {boolean | number | bigint | string} value the value to convert to an expression
-		 * @param {BinaryExpression | UnaryExpression} expr the expression being evaluated
-		 * @param {boolean} sideEffects whether the expression has side effects
-		 * @returns {BasicEvaluatedExpression | undefined} the evaluated expression
-		 * @example
-		 *
-		 * ```js
-		 * const binaryExpr = new BinaryExpression("+",
-		 * 	{ type: "Literal", value: 2 },
-		 * 	{ type: "Literal", value: 3 }
-		 * );
-		 *
-		 * const leftValue = 2;
-		 * const rightValue = 3;
-		 *
-		 * const leftExpr = valueAsExpression(leftValue, binaryExpr.left, false);
-		 * const rightExpr = valueAsExpression(rightValue, binaryExpr.right, false);
-		 * const result = new BasicEvaluatedExpression()
-		 * 	.setNumber(leftExpr.number + rightExpr.number)
-		 * 	.setRange(binaryExpr.range);
-		 *
-		 * console.log(result.number); // Output: 5
-		 * ```
-		 */
-		const valueAsExpression = (value, expr, sideEffects) => {
-			switch (typeof value) {
-				case "boolean":
-					return new BasicEvaluatedExpression()
-						.setBoolean(value)
-						.setSideEffects(sideEffects)
-						.setRange(/** @type {Range} */ (expr.range));
-				case "number":
-					return new BasicEvaluatedExpression()
-						.setNumber(value)
-						.setSideEffects(sideEffects)
-						.setRange(/** @type {Range} */ (expr.range));
-				case "bigint":
-					return new BasicEvaluatedExpression()
-						.setBigInt(value)
-						.setSideEffects(sideEffects)
-						.setRange(/** @type {Range} */ (expr.range));
-				case "string":
-					return new BasicEvaluatedExpression()
-						.setString(value)
-						.setSideEffects(sideEffects)
-						.setRange(/** @type {Range} */ (expr.range));
-			}
-		};
-
 		this.hooks.evaluate.for("BinaryExpression").tap(CLASS_NAME, (_expr) => {
 			const expr = /** @type {BinaryExpression} */ (_expr);
 
-			/**
-			 * Evaluates a binary expression if and only if it is a const operation (e.g. 1 + 2, "a" + "b", etc.).
-			 * @template T
-			 * @param {(leftOperand: T, rightOperand: T) => boolean | number | bigint | string} operandHandler the handler for the operation (e.g. (a, b) => a + b)
-			 * @returns {BasicEvaluatedExpression | undefined} the evaluated expression
-			 */
-			const handleConstOperation = (operandHandler) => {
-				const left = this.evaluateExpression(expr.left);
-				if (!left.isCompileTimeValue()) return;
-
-				const right = this.evaluateExpression(expr.right);
-				if (!right.isCompileTimeValue()) return;
-
-				const result = operandHandler(
-					/** @type {T} */ (left.asCompileTimeValue()),
-					/** @type {T} */ (right.asCompileTimeValue())
-				);
-				return valueAsExpression(
-					result,
-					expr,
-					left.couldHaveSideEffects() || right.couldHaveSideEffects()
-				);
-			};
-
-			/**
-			 * Helper function to determine if two booleans are always different. This is used in `handleStrictEqualityComparison`
-			 * to determine if an expressions boolean or nullish conversion is equal or not.
-			 * @param {boolean} a first boolean to compare
-			 * @param {boolean} b second boolean to compare
-			 * @returns {boolean} true if the two booleans are always different, false otherwise
-			 */
-			const isAlwaysDifferent = (a, b) =>
-				(a === true && b === false) || (a === false && b === true);
-
-			/**
-			 * Handle template string compare.
-			 * @param {BasicEvaluatedExpression} left left
-			 * @param {BasicEvaluatedExpression} right right
-			 * @param {BasicEvaluatedExpression} res res
-			 * @param {boolean} eql true for "===" and false for "!=="
-			 * @returns {BasicEvaluatedExpression | undefined} result
-			 */
-			const handleTemplateStringCompare = (left, right, res, eql) => {
-				/**
-				 * Returns value.
-				 * @param {BasicEvaluatedExpression[]} parts parts
-				 * @returns {string} value
-				 */
-				const getPrefix = (parts) => {
-					let value = "";
-					for (const p of parts) {
-						const v = p.asString();
-						if (v !== undefined) value += v;
-						else break;
-					}
-					return value;
-				};
-				/**
-				 * Returns value.
-				 * @param {BasicEvaluatedExpression[]} parts parts
-				 * @returns {string} value
-				 */
-				const getSuffix = (parts) => {
-					let value = "";
-					for (let i = parts.length - 1; i >= 0; i--) {
-						const v = parts[i].asString();
-						if (v !== undefined) value = v + value;
-						else break;
-					}
-					return value;
-				};
-				const leftPrefix = getPrefix(
-					/** @type {BasicEvaluatedExpression[]} */ (left.parts)
-				);
-				const rightPrefix = getPrefix(
-					/** @type {BasicEvaluatedExpression[]} */ (right.parts)
-				);
-				const leftSuffix = getSuffix(
-					/** @type {BasicEvaluatedExpression[]} */ (left.parts)
-				);
-				const rightSuffix = getSuffix(
-					/** @type {BasicEvaluatedExpression[]} */ (right.parts)
-				);
-				const lenPrefix = Math.min(leftPrefix.length, rightPrefix.length);
-				const lenSuffix = Math.min(leftSuffix.length, rightSuffix.length);
-				const prefixMismatch =
-					lenPrefix > 0 &&
-					leftPrefix.slice(0, lenPrefix) !== rightPrefix.slice(0, lenPrefix);
-				const suffixMismatch =
-					lenSuffix > 0 &&
-					leftSuffix.slice(-lenSuffix) !== rightSuffix.slice(-lenSuffix);
-				if (prefixMismatch || suffixMismatch) {
-					return res
-						.setBoolean(!eql)
-						.setSideEffects(
-							left.couldHaveSideEffects() || right.couldHaveSideEffects()
-						);
-				}
-			};
-
-			/**
-			 * Helper function to handle BinaryExpressions using strict equality comparisons (e.g. "===" and "!==").
-			 * @param {boolean} eql true for "===" and false for "!=="
-			 * @returns {BasicEvaluatedExpression | undefined} the evaluated expression
-			 */
-			const handleStrictEqualityComparison = (eql) => {
-				const left = this.evaluateExpression(expr.left);
-				const right = this.evaluateExpression(expr.right);
-				const res = new BasicEvaluatedExpression();
-				res.setRange(/** @type {Range} */ (expr.range));
-
-				const leftConst = left.isCompileTimeValue();
-				const rightConst = right.isCompileTimeValue();
-
-				if (leftConst && rightConst) {
-					return res
-						.setBoolean(
-							eql === (left.asCompileTimeValue() === right.asCompileTimeValue())
-						)
-						.setSideEffects(
-							left.couldHaveSideEffects() || right.couldHaveSideEffects()
-						);
-				}
-
-				if (left.isArray() && right.isArray()) {
-					return res
-						.setBoolean(!eql)
-						.setSideEffects(
-							left.couldHaveSideEffects() || right.couldHaveSideEffects()
-						);
-				}
-				if (left.isTemplateString() && right.isTemplateString()) {
-					return handleTemplateStringCompare(left, right, res, eql);
-				}
-
-				const leftPrimitive = left.isPrimitiveType();
-				const rightPrimitive = right.isPrimitiveType();
-
-				if (
-					// Primitive !== Object or
-					// compile-time object types are never equal to something at runtime
-					(leftPrimitive === false && (leftConst || rightPrimitive === true)) ||
-					(rightPrimitive === false &&
-						(rightConst || leftPrimitive === true)) ||
-					// Different nullish or boolish status also means not equal
-					isAlwaysDifferent(
-						/** @type {boolean} */ (left.asBool()),
-						/** @type {boolean} */ (right.asBool())
-					) ||
-					isAlwaysDifferent(
-						/** @type {boolean} */ (left.asNullish()),
-						/** @type {boolean} */ (right.asNullish())
-					)
-				) {
-					return res
-						.setBoolean(!eql)
-						.setSideEffects(
-							left.couldHaveSideEffects() || right.couldHaveSideEffects()
-						);
-				}
-			};
-
-			/**
-			 * Helper function to handle BinaryExpressions using abstract equality comparisons (e.g. "==" and "!=").
-			 * @param {boolean} eql true for "==" and false for "!="
-			 * @returns {BasicEvaluatedExpression | undefined} the evaluated expression
-			 */
-			const handleAbstractEqualityComparison = (eql) => {
-				const left = this.evaluateExpression(expr.left);
-				const right = this.evaluateExpression(expr.right);
-				const res = new BasicEvaluatedExpression();
-				res.setRange(/** @type {Range} */ (expr.range));
-
-				const leftConst = left.isCompileTimeValue();
-				const rightConst = right.isCompileTimeValue();
-
-				if (leftConst && rightConst) {
-					return res
-						.setBoolean(
-							eql ===
-								// eslint-disable-next-line eqeqeq
-								(left.asCompileTimeValue() == right.asCompileTimeValue())
-						)
-						.setSideEffects(
-							left.couldHaveSideEffects() || right.couldHaveSideEffects()
-						);
-				}
-
-				if (left.isArray() && right.isArray()) {
-					return res
-						.setBoolean(!eql)
-						.setSideEffects(
-							left.couldHaveSideEffects() || right.couldHaveSideEffects()
-						);
-				}
-				if (left.isTemplateString() && right.isTemplateString()) {
-					return handleTemplateStringCompare(left, right, res, eql);
-				}
-			};
-
-			if (expr.operator === "+") {
+			if (expr.operator === "+") {
 				const left = this.evaluateExpression(expr.left);
 				const right = this.evaluateExpression(expr.right);
 				const res = new BasicEvaluatedExpression();
@@ -1416,41 +1868,41 @@ class JavascriptParser extends Parser {
 				res.setRange(/** @type {Range} */ (expr.range));
 				return res;
 			} else if (expr.operator === "-") {
-				return handleConstOperation((l, r) => l - r);
+				return handleConstOperation(this, expr, SUBTRACT);
 			} else if (expr.operator === "*") {
-				return handleConstOperation((l, r) => l * r);
+				return handleConstOperation(this, expr, MULTIPLY);
 			} else if (expr.operator === "/") {
-				return handleConstOperation((l, r) => l / r);
+				return handleConstOperation(this, expr, DIVIDE);
 			} else if (expr.operator === "**") {
-				return handleConstOperation((l, r) => l ** r);
+				return handleConstOperation(this, expr, POWER);
 			} else if (expr.operator === "===") {
-				return handleStrictEqualityComparison(true);
+				return handleStrictEqualityComparison(this, expr, true);
 			} else if (expr.operator === "==") {
-				return handleAbstractEqualityComparison(true);
+				return handleAbstractEqualityComparison(this, expr, true);
 			} else if (expr.operator === "!==") {
-				return handleStrictEqualityComparison(false);
+				return handleStrictEqualityComparison(this, expr, false);
 			} else if (expr.operator === "!=") {
-				return handleAbstractEqualityComparison(false);
+				return handleAbstractEqualityComparison(this, expr, false);
 			} else if (expr.operator === "&") {
-				return handleConstOperation((l, r) => l & r);
+				return handleConstOperation(this, expr, BITWISE_AND);
 			} else if (expr.operator === "|") {
-				return handleConstOperation((l, r) => l | r);
+				return handleConstOperation(this, expr, BITWISE_OR);
 			} else if (expr.operator === "^") {
-				return handleConstOperation((l, r) => l ^ r);
+				return handleConstOperation(this, expr, BITWISE_XOR);
 			} else if (expr.operator === ">>>") {
-				return handleConstOperation((l, r) => l >>> r);
+				return handleConstOperation(this, expr, UNSIGNED_SHIFT_RIGHT);
 			} else if (expr.operator === ">>") {
-				return handleConstOperation((l, r) => l >> r);
+				return handleConstOperation(this, expr, SHIFT_RIGHT);
 			} else if (expr.operator === "<<") {
-				return handleConstOperation((l, r) => l << r);
+				return handleConstOperation(this, expr, SHIFT_LEFT);
 			} else if (expr.operator === "<") {
-				return handleConstOperation((l, r) => l < r);
+				return handleConstOperation(this, expr, LESS_THAN);
 			} else if (expr.operator === ">") {
-				return handleConstOperation((l, r) => l > r);
+				return handleConstOperation(this, expr, GREATER_THAN);
 			} else if (expr.operator === "<=") {
-				return handleConstOperation((l, r) => l <= r);
+				return handleConstOperation(this, expr, LESS_THAN_OR_EQUAL);
 			} else if (expr.operator === ">=") {
-				return handleConstOperation((l, r) => l >= r);
+				return handleConstOperation(this, expr, GREATER_THAN_OR_EQUAL);
 			} else if (expr.operator === "in") {
 				// `x in y` always evaluates to a boolean, so it is never nullish
 				const left = this.evaluateExpression(expr.left);
@@ -1466,25 +1918,10 @@ class JavascriptParser extends Parser {
 		this.hooks.evaluate.for("UnaryExpression").tap(CLASS_NAME, (_expr) => {
 			const expr = /** @type {UnaryExpression} */ (_expr);
 
-			/**
-			 * Evaluates a UnaryExpression if and only if it is a basic const operator (e.g. +a, -a, ~a).
-			 * @template T
-			 * @param {(operand: T) => boolean | number | bigint | string} operandHandler handler for the operand
-			 * @returns {BasicEvaluatedExpression | undefined} evaluated expression
-			 */
-			const handleConstOperation = (operandHandler) => {
-				const argument = this.evaluateExpression(expr.argument);
-				if (!argument.isCompileTimeValue()) return;
-				const result = operandHandler(
-					/** @type {T} */ (argument.asCompileTimeValue())
-				);
-				return valueAsExpression(result, expr, argument.couldHaveSideEffects());
-			};
-
 			if (expr.operator === "typeof") {
 				switch (expr.argument.type) {
 					case "Identifier": {
-						const res = this.callHooksForName(
+						const res = this._callHooksForName1(
 							this.hooks.evaluateTypeof,
 							expr.argument.name,
 							expr
@@ -1493,7 +1930,7 @@ class JavascriptParser extends Parser {
 						break;
 					}
 					case "MetaProperty": {
-						const res = this.callHooksForName(
+						const res = this._callHooksForName1(
 							this.hooks.evaluateTypeof,
 							/** @type {string} */
 							(getRootName(expr.argument)),
@@ -1579,12 +2016,11 @@ class JavascriptParser extends Parser {
 					.setSideEffects(argument.couldHaveSideEffects())
 					.setRange(/** @type {Range} */ (expr.range));
 			} else if (expr.operator === "~") {
-				return handleConstOperation((v) => ~v);
+				return handleUnaryConstOperation(this, expr, BITWISE_NOT);
 			} else if (expr.operator === "+") {
-				// eslint-disable-next-line no-implicit-coercion
-				return handleConstOperation((v) => +v);
+				return handleUnaryConstOperation(this, expr, TO_NUMBER);
 			} else if (expr.operator === "-") {
-				return handleConstOperation((v) => -v);
+				return handleUnaryConstOperation(this, expr, NEGATE);
 			}
 		});
 		this.hooks.evaluateTypeof
@@ -1623,18 +2059,18 @@ class JavascriptParser extends Parser {
 				cachedExpression = expression;
 				cachedInfo = info;
 				if (info !== undefined) {
-					return this.callHooksForInfoWithFallback(
+					// saved around the call: a hook may evaluate another identifier
+					const outer = this._evaluatingExpression;
+					this._evaluatingExpression = expression;
+					const result = this.callHooksForInfoWithFallback(
 						this.hooks.evaluateIdentifier,
 						info.name,
-						(_name) => undefined,
-						(name) => {
-							const hook = this.hooks.evaluateDefinedIdentifier.get(name);
-							if (hook !== undefined) {
-								return hook.call(expression);
-							}
-						},
+						RETURN_UNDEFINED,
+						this._evaluateDefinedIdentifier,
 						expression
 					);
+					this._evaluatingExpression = outer;
+					return result;
 				}
 			});
 			this.hooks.evaluate
@@ -1699,7 +2135,7 @@ class JavascriptParser extends Parser {
 		this.hooks.evaluate.for("MetaProperty").tap(CLASS_NAME, (expr) => {
 			const metaProperty = /** @type {MetaProperty} */ (expr);
 
-			return this.callHooksForName(
+			return this._callHooksForName1(
 				this.hooks.evaluateIdentifier,
 				/** @type {string} */
 				(getRootName(metaProperty)),
@@ -1733,7 +2169,7 @@ class JavascriptParser extends Parser {
 					return hook.call(expr, param);
 				}
 			} else if (expr.callee.type === "Identifier") {
-				return this.callHooksForName(
+				return this._callHooksForName1(
 					this.hooks.evaluateCallExpression,
 					expr.callee.name,
 					expr
@@ -2209,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) {
@@ -2235,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++) {
@@ -2255,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
@@ -2304,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;
@@ -2491,26 +3190,20 @@ class JavascriptParser extends Parser {
 	}
 
 	// Real Statements
-	/**
-	 * Pre walk block statement.
-	 * @param {BlockStatement} statement block statement
-	 */
-	preWalkBlockStatement(statement) {
-		this.preWalkStatements(statement.body);
-	}
 
 	/**
 	 * Walk block statement.
 	 * @param {BlockStatement | StaticBlock} statement block statement
 	 */
 	walkBlockStatement(statement) {
-		this.inBlockScope(() => {
-			const body = statement.body;
-			const prev = this.prevStatement;
-			this.blockPreWalkStatements(body);
-			this.prevStatement = prev;
-			this.walkStatements(body);
-		}, true);
+		const oldScope = this._enterBlockScope();
+		const body = statement.body;
+		const prev = this.prevStatement;
+		this._blockPreWalkScope(statement, body);
+		this.prevStatement = prev;
+		this.walkStatements(body);
+
+		this._exitBlockScope(oldScope, true);
 	}
 
 	/**
@@ -2521,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.
@@ -2562,18 +3244,27 @@ class JavascriptParser extends Parser {
 		if (result === undefined) {
 			const guard = this.hooks.collectGuards.call(statement.test);
 			this.walkExpression(statement.test);
-			this.walkGuardedBranch(guard ? guard.consequent : undefined, () =>
-				this.walkNestedStatement(statement.consequent)
-			);
+			// allocate the branch closure only when a guard frame needs pushing
+			if (guard && guard.consequent) {
+				this.walkGuardedBranch(guard.consequent, () =>
+					this.walkNestedStatement(statement.consequent)
+				);
+			} else {
+				this.walkNestedStatement(statement.consequent);
+			}
 
 			const consequentTerminated = this.scope.terminated;
 			this.scope.terminated = undefined;
 
 			if (statement.alternate) {
 				const alternate = statement.alternate;
-				this.walkGuardedBranch(guard ? guard.alternate : undefined, () =>
-					this.walkNestedStatement(alternate)
-				);
+				if (guard && guard.alternate) {
+					this.walkGuardedBranch(guard.alternate, () =>
+						this.walkNestedStatement(alternate)
+					);
+				} else {
+					this.walkNestedStatement(alternate);
+				}
 			}
 
 			const alternateTerminated = this.scope.terminated;
@@ -2589,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
@@ -2607,17 +3290,10 @@ class JavascriptParser extends Parser {
 			const result = hook.call(statement);
 			if (result === true) return;
 		}
-		this.inBlockScope(() => {
-			this.walkNestedStatement(statement.body);
-		});
-	}
+		const oldScope = this._enterBlockScope();
+		this.walkNestedStatement(statement.body);
 
-	/**
-	 * Pre walk with statement.
-	 * @param {WithStatement} statement with statement
-	 */
-	preWalkWithStatement(statement) {
-		this.preWalkStatement(statement.body);
+		this._exitBlockScope(oldScope, false);
 	}
 
 	/**
@@ -2631,18 +3307,11 @@ class JavascriptParser extends Parser {
 				statement
 			);
 		}
-		this.inBlockScope(() => {
-			this.walkExpression(statement.object);
-			this.walkNestedStatement(statement.body);
-		});
-	}
+		const oldScope = this._enterBlockScope();
+		this.walkExpression(statement.object);
+		this.walkNestedStatement(statement.body);
 
-	/**
-	 * Pre walk switch statement.
-	 * @param {SwitchStatement} statement switch statement
-	 */
-	preWalkSwitchStatement(statement) {
-		this.preWalkSwitchCases(statement.cases);
+		this._exitBlockScope(oldScope, false);
 	}
 
 	/**
@@ -2686,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
@@ -2734,53 +3393,28 @@ 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
 	 */
 	walkWhileStatement(statement) {
-		this.inBlockScope(() => {
-			this.walkExpression(statement.test);
-			this.walkNestedStatement(statement.body);
-		});
-	}
+		const oldScope = this._enterBlockScope();
+		this.walkExpression(statement.test);
+		this.walkNestedStatement(statement.body);
 
-	/**
-	 * 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
-	 */
-	walkDoWhileStatement(statement) {
-		this.inBlockScope(() => {
-			this.walkNestedStatement(statement.body);
-			this.walkExpression(statement.test);
-		});
+		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 do while statement.
+	 * @param {DoWhileStatement} statement do while statement
+	 */
+	walkDoWhileStatement(statement) {
+		const oldScope = this._enterBlockScope();
+		this.walkNestedStatement(statement.body);
+		this.walkExpression(statement.test);
+
+		this._exitBlockScope(oldScope, false);
 	}
 
 	/**
@@ -2788,46 +3422,36 @@ class JavascriptParser extends Parser {
 	 * @param {ForStatement} statement for statement
 	 */
 	walkForStatement(statement) {
-		this.inBlockScope(() => {
-			if (statement.init) {
-				if (statement.init.type === "VariableDeclaration") {
-					this.blockPreWalkVariableDeclaration(statement.init);
-					this.prevStatement = undefined;
-					this.walkStatement(statement.init);
-				} else {
-					this.walkExpression(statement.init);
-				}
-			}
-			if (statement.test) {
-				this.walkExpression(statement.test);
-			}
-			if (statement.update) {
-				this.walkExpression(statement.update);
-			}
-
-			const body = statement.body;
-
-			if (body.type === "BlockStatement") {
-				// no need to add additional scope
-				const prev = this.prevStatement;
-				this.blockPreWalkStatements(body.body);
-				this.prevStatement = prev;
-				this.walkStatements(body.body);
+		const oldScope = this._enterBlockScope();
+		if (statement.init) {
+			if (statement.init.type === "VariableDeclaration") {
+				this.blockPreWalkVariableDeclaration(statement.init);
+				this.prevStatement = undefined;
+				this.walkStatement(statement.init);
 			} else {
-				this.walkNestedStatement(body);
+				this.walkExpression(statement.init);
 			}
-		});
-	}
+		}
+		if (statement.test) {
+			this.walkExpression(statement.test);
+		}
+		if (statement.update) {
+			this.walkExpression(statement.update);
+		}
 
-	/**
-	 * Pre walk for in statement.
-	 * @param {ForInStatement} statement for statement
-	 */
-	preWalkForInStatement(statement) {
-		if (statement.left.type === "VariableDeclaration") {
-			this.preWalkVariableDeclaration(statement.left);
+		const body = statement.body;
+
+		if (body.type === "BlockStatement") {
+			// no need to add additional scope
+			const prev = this.prevStatement;
+			this._blockPreWalkScope(body, body.body);
+			this.prevStatement = prev;
+			this.walkStatements(body.body);
+		} else {
+			this.walkNestedStatement(body);
 		}
-		this.preWalkStatement(statement.body);
+
+		this._exitBlockScope(oldScope, false);
 	}
 
 	/**
@@ -2835,71 +3459,62 @@ class JavascriptParser extends Parser {
 	 * @param {ForInStatement} statement for statement
 	 */
 	walkForInStatement(statement) {
-		this.inBlockScope(() => {
-			if (statement.left.type === "VariableDeclaration") {
-				this.blockPreWalkVariableDeclaration(statement.left);
-				this.walkVariableDeclaration(statement.left);
-			} else {
-				this.walkPattern(statement.left);
-			}
+		const oldScope = this._enterBlockScope();
+		if (statement.left.type === "VariableDeclaration") {
+			this.blockPreWalkVariableDeclaration(statement.left);
+			this.walkVariableDeclaration(statement.left);
+		} else if (!this._walkWriteTarget(statement.left, statement)) {
+			this.walkPattern(statement.left);
+		}
 
-			this.walkExpression(statement.right);
+		this.walkExpression(statement.right);
 
-			const body = statement.body;
+		const body = statement.body;
 
-			if (body.type === "BlockStatement") {
-				// no need to add additional scope
-				const prev = this.prevStatement;
-				this.blockPreWalkStatements(body.body);
-				this.prevStatement = prev;
-				this.walkStatements(body.body);
-			} else {
-				this.walkNestedStatement(body);
-			}
-		});
+		if (body.type === "BlockStatement") {
+			// no need to add additional scope
+			const prev = this.prevStatement;
+			this._blockPreWalkScope(body, body.body);
+			this.prevStatement = prev;
+			this.walkStatements(body.body);
+		} else {
+			this.walkNestedStatement(body);
+		}
+
+		this._exitBlockScope(oldScope, false);
 	}
 
 	/**
-	 * Pre walk for of statement.
-	 * @param {ForOfStatement} statement statement
+	 * Walk for of statement.
+	 * @param {ForOfStatement} statement for statement
 	 */
-	preWalkForOfStatement(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.preWalkVariableDeclaration(statement.left);
+			this.blockPreWalkVariableDeclaration(statement.left);
+			this.walkVariableDeclaration(statement.left);
+		} else if (!this._walkWriteTarget(statement.left, statement)) {
+			this.walkPattern(statement.left);
 		}
-		this.preWalkStatement(statement.body);
-	}
 
-	/**
-	 * Walk for of statement.
-	 * @param {ForOfStatement} statement for statement
-	 */
-	walkForOfStatement(statement) {
-		this.inBlockScope(() => {
-			if (statement.left.type === "VariableDeclaration") {
-				this.blockPreWalkVariableDeclaration(statement.left);
-				this.walkVariableDeclaration(statement.left);
-			} else {
-				this.walkPattern(statement.left);
-			}
+		this.walkExpression(statement.right);
 
-			this.walkExpression(statement.right);
+		const body = statement.body;
 
-			const body = statement.body;
+		if (body.type === "BlockStatement") {
+			// no need to add additional scope
+			const prev = this.prevStatement;
+			this._blockPreWalkScope(body, body.body);
+			this.prevStatement = prev;
+			this.walkStatements(body.body);
+		} else {
+			this.walkNestedStatement(body);
+		}
 
-			if (body.type === "BlockStatement") {
-				// no need to add additional scope
-				const prev = this.prevStatement;
-				this.blockPreWalkStatements(body.body);
-				this.prevStatement = prev;
-				this.walkStatements(body.body);
-			} else {
-				this.walkNestedStatement(body);
-			}
-		});
+		this._exitBlockScope(oldScope, false);
 	}
 
 	/**
@@ -2925,19 +3540,20 @@ class JavascriptParser extends Parser {
 		if (this._strictInModuleOutput) {
 			this._checkStrictModeParams(statement.params);
 		}
-		this.inFunctionScope(true, statement.params, () => {
-			for (const param of statement.params) {
-				this.walkPattern(param);
-			}
+		const oldScope = this._enterFunctionScope(true, statement.params);
+		for (const param of statement.params) {
+			this.walkPattern(param);
+		}
 
-			this.detectMode(statement.body.body);
+		this.detectMode(statement.body.body);
 
-			const prev = this.prevStatement;
+		const prev = this.prevStatement;
 
-			this.preWalkStatement(statement.body);
-			this.prevStatement = prev;
-			this.walkStatement(statement.body);
-		});
+		this._preWalkScope(statement.body);
+		this.prevStatement = prev;
+		this.walkStatement(statement.body);
+
+		this.scope = oldScope;
 		this.scope.topLevelScope = wasTopLevel;
 	}
 
@@ -3303,7 +3919,9 @@ class JavascriptParser extends Parser {
 		/** @type {OnIdent | undefined} */
 		let onIdent;
 		const checkStrictBindings = this._strictInModuleOutput;
-		for (const declarator of statement.declarations) {
+		const declarations = statement.declarations;
+		for (let i = 0, len = declarations.length; i < len; i++) {
+			const declarator = declarations[i];
 			if (declarator.type !== "VariableDeclarator") continue;
 			this.preWalkVariableDeclarator(declarator);
 			if (this.hooks.preDeclarator.call(declarator, statement)) continue;
@@ -3312,7 +3930,7 @@ class JavascriptParser extends Parser {
 				if (checkStrictBindings) this._checkStrictModeBinding(id.name, id);
 				// fast path: plain `const x =` skips the enterPattern dispatch and
 				// the per-declaration onIdent closure (only patterns need it)
-				if (!this.callHooksForName(this.hooks.pattern, id.name, id)) {
+				if (!this._callHooksForName1(this.hooks.pattern, id.name, id)) {
 					this._defineVariableForDeclaration(id.name, id, hookMap);
 				}
 			} else {
@@ -3452,7 +4070,9 @@ class JavascriptParser extends Parser {
 	 * @param {VariableDeclaration} statement variable declaration
 	 */
 	walkVariableDeclaration(statement) {
-		for (const declarator of statement.declarations) {
+		const declarations = statement.declarations;
+		for (let i = 0, len = declarations.length; i < len; i++) {
+			const declarator = declarations[i];
 			switch (declarator.type) {
 				case "VariableDeclarator": {
 					const renameIdentifier =
@@ -3507,64 +4127,40 @@ 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
 	 */
 	walkSwitchCases(switchCases) {
-		this.inBlockScope(() => {
-			const len = switchCases.length;
-
-			// we need to pre walk all statements first since we can have invalid code
-			// import A from "module";
-			// switch(1) {
-			//    case 1:
-			//      console.log(A); // should fail at runtime
-			//    case 2:
-			//      const A = 1;
-			// }
-			for (let index = 0; index < len; index++) {
-				const switchCase = switchCases[index];
-
-				if (switchCase.consequent.length > 0) {
-					const prev = this.prevStatement;
-					this.blockPreWalkStatements(switchCase.consequent);
-					this.prevStatement = prev;
-				}
+		const oldScope = this._enterBlockScope();
+		const len = switchCases.length;
+
+		// pre-walk every case first: a `const` declared in a later case is already
+		// in scope for an earlier case that reads it (and fails at runtime)
+		for (let index = 0; index < len; index++) {
+			const switchCase = switchCases[index];
+
+			if (switchCase.consequent.length > 0) {
+				const prev = this.prevStatement;
+				this._blockPreWalkScope(switchCase, switchCase.consequent);
+				this.prevStatement = prev;
 			}
+		}
 
-			for (let index = 0; index < len; index++) {
-				const switchCase = switchCases[index];
+		for (let index = 0; index < len; index++) {
+			const switchCase = switchCases[index];
 
-				if (switchCase.test) {
-					this.walkExpression(switchCase.test);
-				}
+			if (switchCase.test) {
+				this.walkExpression(switchCase.test);
+			}
 
-				if (switchCase.consequent.length > 0) {
-					this.walkStatements(switchCase.consequent);
-					this.scope.terminated = undefined;
-				}
+			if (switchCase.consequent.length > 0) {
+				this.walkStatements(switchCase.consequent);
+				this.scope.terminated = undefined;
 			}
-		});
-	}
+		}
 
-	/**
-	 * Pre walk catch clause.
-	 * @param {CatchClause} catchClause catch clause
-	 */
-	preWalkCatchClause(catchClause) {
-		this.preWalkStatement(catchClause.body);
+		this._exitBlockScope(oldScope, false);
 	}
 
 	/**
@@ -3572,22 +4168,23 @@ class JavascriptParser extends Parser {
 	 * @param {CatchClause} catchClause catch clause
 	 */
 	walkCatchClause(catchClause) {
-		this.inBlockScope(() => {
-			// Error binding is optional in catch clause since ECMAScript 2019
-			if (catchClause.param !== null) {
-				this.enterPattern(catchClause.param, (ident, identifier) => {
-					if (this._strictInModuleOutput) {
-						this._checkStrictModeBinding(ident, identifier);
-					}
-					this.defineVariable(ident);
-				});
-				this.walkPattern(catchClause.param);
-			}
-			const prev = this.prevStatement;
-			this.blockPreWalkStatement(catchClause.body);
-			this.prevStatement = prev;
-			this.walkStatement(catchClause.body);
-		}, true);
+		const oldScope = this._enterBlockScope();
+		// Error binding is optional in catch clause since ECMAScript 2019
+		if (catchClause.param !== null) {
+			this.enterPattern(catchClause.param, (ident, identifier) => {
+				if (this._strictInModuleOutput) {
+					this._checkStrictModeBinding(ident, identifier);
+				}
+				this.defineVariable(ident);
+			});
+			this.walkPattern(catchClause.param);
+		}
+		const prev = this.prevStatement;
+		this.blockPreWalkStatement(catchClause.body);
+		this.prevStatement = prev;
+		this.walkStatement(catchClause.body);
+
+		this._exitBlockScope(oldScope, true);
 	}
 
 	/**
@@ -3885,19 +4482,20 @@ class JavascriptParser extends Parser {
 				this._checkStrictModeBinding(expression.id.name, expression.id);
 			}
 		}
-		this.inFunctionScope(true, scopeParams, () => {
-			for (const param of expression.params) {
-				this.walkPattern(param);
-			}
+		const oldScope = this._enterFunctionScope(true, scopeParams);
+		for (const param of expression.params) {
+			this.walkPattern(param);
+		}
 
-			this.detectMode(expression.body.body);
+		this.detectMode(expression.body.body);
 
-			const prev = this.prevStatement;
+		const prev = this.prevStatement;
 
-			this.preWalkStatement(expression.body);
-			this.prevStatement = prev;
-			this.walkStatement(expression.body);
-		});
+		this._preWalkScope(expression.body);
+		this.prevStatement = prev;
+		this.walkStatement(expression.body);
+
+		this.scope = oldScope;
 		this.scope.topLevelScope = wasTopLevel;
 	}
 
@@ -3911,20 +4509,21 @@ class JavascriptParser extends Parser {
 		if (this._strictInModuleOutput) {
 			this._checkStrictModeParams(expression.params);
 		}
-		this.inFunctionScope(false, expression.params, () => {
-			for (const param of expression.params) {
-				this.walkPattern(param);
-			}
-			if (expression.body.type === "BlockStatement") {
-				this.detectMode(expression.body.body);
-				const prev = this.prevStatement;
-				this.preWalkStatement(expression.body);
-				this.prevStatement = prev;
-				this.walkStatement(expression.body);
-			} else {
-				this.walkExpression(expression.body);
-			}
-		});
+		const oldScope = this._enterFunctionScope(false, expression.params);
+		for (const param of expression.params) {
+			this.walkPattern(param);
+		}
+		if (expression.body.type === "BlockStatement") {
+			this.detectMode(expression.body.body);
+			const prev = this.prevStatement;
+			this._preWalkScope(expression.body);
+			this.prevStatement = prev;
+			this.walkStatement(expression.body);
+		} else {
+			this.walkExpression(expression.body);
+		}
+
+		this.scope = oldScope;
 		this.scope.topLevelScope = wasTopLevel;
 	}
 
@@ -3978,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.
@@ -4185,7 +4873,7 @@ class JavascriptParser extends Parser {
 			const renameIdentifier = this.getRenameIdentifier(expression.right);
 			if (
 				renameIdentifier &&
-				this.callHooksForInfo(
+				this._callHooksForInfo1(
 					this.hooks.canRename,
 					renameIdentifier,
 					expression.right
@@ -4193,7 +4881,7 @@ class JavascriptParser extends Parser {
 			) {
 				// renaming "a = b;"
 				if (
-					!this.callHooksForInfo(
+					!this._callHooksForInfo1(
 						this.hooks.rename,
 						renameIdentifier,
 						expression.right
@@ -4209,34 +4897,43 @@ class JavascriptParser extends Parser {
 				return;
 			}
 			this.walkExpression(expression.right);
-			this.enterPattern(expression.left, (name, _decl) => {
-				if (!this.callHooksForName(this.hooks.assign, name, expression)) {
-					this.walkExpression(
-						/** @type {MemberExpression} */
-						(expression.left)
-					);
-				}
-			});
+			// inlined enterPattern → enterIdentifier for the Identifier left side:
+			// same hook sequence without the per-assignment closure
+			const leftName = expression.left.name;
+			if (
+				!this._callHooksForName1(
+					this.hooks.pattern,
+					leftName,
+					expression.left
+				) &&
+				!this._callHooksForName1(this.hooks.assign, leftName, expression)
+			) {
+				this.walkExpression(expression.left);
+			}
 		} else if (expression.left.type.endsWith("Pattern")) {
 			this.walkExpression(expression.right);
 			this.enterPattern(expression.left, (name, _decl) => {
-				if (!this.callHooksForName(this.hooks.assign, name, expression)) {
+				if (!this._callHooksForName1(this.hooks.assign, name, expression)) {
 					this.defineVariable(name);
 				}
 			});
+			this._walkPatternWriteMembers(expression.left, expression);
 			this.walkPattern(expression.left);
 		} else if (expression.left.type === "MemberExpression") {
-			const exprName = this.getMemberExpressionInfo(
-				expression.left,
-				ALLOWED_MEMBER_TYPES_EXPRESSION
-			);
 			if (
-				exprName &&
+				this._resolveMemberExpression(
+					expression.left,
+					ALLOWED_MEMBER_TYPES_EXPRESSION
+				) === 1 &&
+				this._hasHooksForInfo(
+					this.hooks.assignMemberChain,
+					/** @type {string | VariableInfo} */ (this._memberRootInfo)
+				) &&
 				this.callHooksForInfo(
 					this.hooks.assignMemberChain,
-					exprName.rootInfo,
+					/** @type {string | VariableInfo} */ (this._memberRootInfo),
 					expression,
-					exprName.getMembers()
+					this._members
 				)
 			) {
 				return;
@@ -4261,15 +4958,24 @@ class JavascriptParser extends Parser {
 		if (result === undefined) {
 			const guard = this.hooks.collectGuards.call(expression.test);
 			this.walkExpression(expression.test);
-			this.walkGuardedBranch(guard ? guard.consequent : undefined, () =>
-				this.walkExpression(expression.consequent)
-			);
+			// allocate the branch closure only when a guard frame needs pushing
+			if (guard && guard.consequent) {
+				this.walkGuardedBranch(guard.consequent, () =>
+					this.walkExpression(expression.consequent)
+				);
+			} else {
+				this.walkExpression(expression.consequent);
+			}
 
 			if (expression.alternate) {
 				const alternate = expression.alternate;
-				this.walkGuardedBranch(guard ? guard.alternate : undefined, () =>
-					this.walkExpression(alternate)
-				);
+				if (guard && guard.alternate) {
+					this.walkGuardedBranch(guard.alternate, () =>
+						this.walkExpression(alternate)
+					);
+				} else {
+					this.walkExpression(alternate);
+				}
 			}
 		} else if (result) {
 			this.walkExpression(expression.consequent);
@@ -4375,13 +5081,13 @@ class JavascriptParser extends Parser {
 			const renameIdentifier = this.getRenameIdentifier(argOrThis);
 			if (
 				renameIdentifier &&
-				this.callHooksForInfo(
+				this._callHooksForInfo1(
 					this.hooks.canRename,
 					renameIdentifier,
 					/** @type {Expression} */
 					(argOrThis)
 				) &&
-				!this.callHooksForInfo(
+				!this._callHooksForInfo1(
 					this.hooks.rename,
 					renameIdentifier,
 					/** @type {Expression} */
@@ -4422,26 +5128,27 @@ class JavascriptParser extends Parser {
 			scopeParams.push(functionExpression.id.name);
 		}
 
-		this.inFunctionScope(true, scopeParams, () => {
-			if (renameThis && !arrow) {
-				this.setVariable("this", renameThis);
-			}
-			for (let i = 0; i < varInfoForArgs.length; i++) {
-				const varInfo = varInfoForArgs[i];
-				if (!varInfo) continue;
-				if (!params[i] || params[i].type !== "Identifier") continue;
-				this.setVariable(/** @type {Identifier} */ (params[i]).name, varInfo);
-			}
-			if (functionExpression.body.type === "BlockStatement") {
-				this.detectMode(functionExpression.body.body);
-				const prev = this.prevStatement;
-				this.preWalkStatement(functionExpression.body);
-				this.prevStatement = prev;
-				this.walkStatement(functionExpression.body);
-			} else {
-				this.walkExpression(functionExpression.body);
-			}
-		});
+		const oldScope = this._enterFunctionScope(true, scopeParams);
+		if (renameThis && !arrow) {
+			this.setVariable("this", renameThis);
+		}
+		for (let i = 0; i < varInfoForArgs.length; i++) {
+			const varInfo = varInfoForArgs[i];
+			if (!varInfo) continue;
+			if (!params[i] || params[i].type !== "Identifier") continue;
+			this.setVariable(/** @type {Identifier} */ (params[i]).name, varInfo);
+		}
+		if (functionExpression.body.type === "BlockStatement") {
+			this.detectMode(functionExpression.body.body);
+			const prev = this.prevStatement;
+			this._preWalkScope(functionExpression.body);
+			this.prevStatement = prev;
+			this.walkStatement(functionExpression.body);
+		} else {
+			this.walkExpression(functionExpression.body);
+		}
+
+		this.scope = oldScope;
 		this.scope.topLevelScope = wasTopLevel;
 	}
 
@@ -4553,22 +5260,26 @@ class JavascriptParser extends Parser {
 			}
 			const callee = this.evaluateExpression(expression.callee);
 			if (callee.isIdentifier()) {
-				const members =
-					/** @type {NonNullable<BasicEvaluatedExpression["getMembers"]>} */
-					(callee.getMembers)();
-				const result1 = this.callHooksForInfo(
-					this.hooks.callMemberChain,
+				const rootInfo =
 					/** @type {NonNullable<BasicEvaluatedExpression["rootInfo"]>} */
-					(callee.rootInfo),
-					expression,
-					members,
-					callee.getMembersOptionals
-						? callee.getMembersOptionals()
-						: members.map(RETURN_FALSE),
-					callee.getMemberRanges ? callee.getMemberRanges() : []
-				);
-				if (result1 === true) return;
-				const result2 = this.callHooksForInfo(
+					(callee.rootInfo);
+				if (this._hasHooksForInfo(this.hooks.callMemberChain, rootInfo)) {
+					const members =
+						/** @type {NonNullable<BasicEvaluatedExpression["getMembers"]>} */
+						(callee.getMembers)();
+					const result1 = this.callHooksForInfo(
+						this.hooks.callMemberChain,
+						rootInfo,
+						expression,
+						members,
+						callee.getMembersOptionals
+							? callee.getMembersOptionals()
+							: members.map(RETURN_FALSE),
+						callee.getMemberRanges ? callee.getMemberRanges() : []
+					);
+					if (result1 === true) return;
+				}
+				const result2 = this._callHooksForInfo1(
 					this.hooks.call,
 					/** @type {NonNullable<BasicEvaluatedExpression["identifier"]>} */
 					(callee.identifier),
@@ -4593,69 +5304,113 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
-	 * Walk member expression.
-	 * @param {MemberExpression} expression member expression
+	 * Walk member expression.
+	 * @param {MemberExpression} expression member expression
+	 */
+	walkMemberExpression(expression) {
+		const type = this._resolveMemberExpression(
+			expression,
+			ALLOWED_MEMBER_TYPES_ALL
+		);
+		if (type === 1) {
+			// copied out first: a hook may resolve another chain and reuse the slots
+			const name = this._memberName;
+			const rootInfo = /** @type {string | VariableInfo} */ (
+				this._memberRootInfo
+			);
+			const members = this._members;
+			const membersOptionals = this._membersOptionals;
+			const result1 = this._callHooksForInfo1(
+				this.hooks.expression,
+				name,
+				expression
+			);
+			if (result1 === true) return;
+			if (this._hasHooksForInfo(this.hooks.expressionMemberChain, rootInfo)) {
+				const result2 = this.callHooksForInfo(
+					this.hooks.expressionMemberChain,
+					rootInfo,
+					expression,
+					members,
+					membersOptionals,
+					memberRangesOf(expression, members.length)
+				);
+				if (result2 === true) return;
+			}
+			this._walkMemberChain(
+				expression,
+				expression,
+				name,
+				rootInfo,
+				members,
+				members.length
+			);
+			return;
+		}
+		if (type === 2) {
+			const call = /** @type {CallExpression} */ (this._memberCall);
+			const result = this.callHooksForInfo(
+				this.hooks.memberChainOfCallMemberChain,
+				/** @type {string | VariableInfo} */ (this._memberRootInfo),
+				expression,
+				this._memberCalleeMembers,
+				call,
+				this._members,
+				memberRangesOf(expression, this._members.length)
+			);
+			if (result === true) return;
+			// Fast skip over the member chain as we already called memberChainOfCallMemberChain
+			// and call computed property are literals anyway
+			this.walkExpression(call);
+			return;
+		}
+		this.walkExpression(expression.object);
+		if (expression.computed === true) this.walkExpression(expression.property);
+	}
+
+	/**
+	 * The walk `walkMemberExpressionWithExpressionName` does over a resolved
+	 * chain, reading `members` up to `end` instead of popping a copy of it.
+	 * @param {MemberExpression} outer the whole chain, for the unhandled hook
+	 * @param {MemberExpression} expression the chain from here inwards
+	 * @param {string} name name of `expression`
+	 * @param {string | VariableInfo} rootInfo root info
+	 * @param {Members} members members of the whole chain, in source order
+	 * @param {number} end how many of `members` are inside `expression`
+	 * @returns {void}
 	 */
-	walkMemberExpression(expression) {
-		const exprInfo = this.getMemberExpressionInfo(
-			expression,
-			ALLOWED_MEMBER_TYPES_ALL
-		);
-		if (exprInfo) {
-			switch (exprInfo.type) {
-				case "expression": {
-					const result1 = this.callHooksForInfo(
-						this.hooks.expression,
-						exprInfo.name,
-						expression
-					);
-					if (result1 === true) return;
-					const members = exprInfo.getMembers();
-					const membersOptionals = exprInfo.getMembersOptionals();
-					const memberRanges = exprInfo.getMemberRanges();
-					const result2 = this.callHooksForInfo(
-						this.hooks.expressionMemberChain,
-						exprInfo.rootInfo,
-						expression,
-						members,
-						membersOptionals,
-						memberRanges
-					);
-					if (result2 === true) return;
-					this.walkMemberExpressionWithExpressionName(
-						expression,
-						exprInfo.name,
-						exprInfo.rootInfo,
-						[...members],
-						() =>
-							this.callHooksForInfo(
-								this.hooks.unhandledExpressionMemberChain,
-								exprInfo.rootInfo,
-								expression,
-								members
-							)
-					);
-					return;
-				}
-				case "call": {
-					const result = this.callHooksForInfo(
-						this.hooks.memberChainOfCallMemberChain,
-						exprInfo.rootInfo,
-						expression,
-						exprInfo.getCalleeMembers(),
-						exprInfo.call,
-						exprInfo.getMembers(),
-						exprInfo.getMemberRanges()
-					);
-					if (result === true) return;
-					// Fast skip over the member chain as we already called memberChainOfCallMemberChain
-					// and call computed property are literals anyway
-					this.walkExpression(exprInfo.call);
-					return;
-				}
-			}
+	_walkMemberChain(outer, expression, name, rootInfo, members, end) {
+		if (expression.object.type === "MemberExpression") {
+			const property = members[end - 1];
+			name = name.slice(0, -property.length - 1);
+			const result = this._callHooksForInfo1(
+				this.hooks.expression,
+				name,
+				expression.object
+			);
+			if (result === true) return;
+			this._walkMemberChain(
+				outer,
+				expression.object,
+				name,
+				rootInfo,
+				members,
+				end - 1
+			);
+		} else if (
+			!this._hasHooksForInfo(
+				this.hooks.unhandledExpressionMemberChain,
+				rootInfo
+			) ||
+			!this.callHooksForInfo(
+				this.hooks.unhandledExpressionMemberChain,
+				rootInfo,
+				outer,
+				members
+			)
+		) {
+			this.walkExpression(expression.object);
 		}
-		this.walkExpression(expression.object);
 		if (expression.computed === true) this.walkExpression(expression.property);
 	}
 
@@ -4676,15 +5431,13 @@ 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();
-			const result = this.callHooksForInfo(
+			const result = this._callHooksForInfo1(
 				this.hooks.expression,
 				name,
 				expression.object
@@ -4708,7 +5461,7 @@ class JavascriptParser extends Parser {
 	 * @param {ThisExpression} expression this expression
 	 */
 	walkThisExpression(expression) {
-		this.callHooksForName(this.hooks.expression, "this", expression);
+		this._callHooksForName1(this.hooks.expression, "this", expression);
 	}
 
 	/**
@@ -4716,7 +5469,7 @@ class JavascriptParser extends Parser {
 	 * @param {Identifier} expression identifier
 	 */
 	walkIdentifier(expression) {
-		this.callHooksForName(this.hooks.expression, expression.name, expression);
+		this._callHooksForName1(this.hooks.expression, expression.name, expression);
 	}
 
 	/**
@@ -4882,6 +5635,27 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * Whether `_callHooksForInfo` would call any hook for this info, so a
+	 * caller can skip building the arguments for a name nothing taps.
+	 * @template T
+	 * @template R
+	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks that would be called
+	 * @param {ExportedVariableInfo} info variable info
+	 * @returns {boolean} true when a hook is registered for the info
+	 */
+	_hasHooksForInfo(hookMap, info) {
+		if (typeof info === "string") return hookMap.get(info) !== undefined;
+		if (!(info instanceof VariableInfo)) return false;
+		let tagInfo = info.tagInfo;
+		while (tagInfo !== undefined) {
+			if (hookMap.get(tagInfo.tag) !== undefined) return true;
+			tagInfo = tagInfo.next;
+		}
+		if (!info.isFree() && !info.isTagged()) return false;
+		return hookMap.get(/** @type {string} */ (info.name)) !== undefined;
+	}
+
 	/**
 	 * Call hooks for name with fallback.
 	 * @template T
@@ -4903,6 +5677,69 @@ class JavascriptParser extends Parser {
 		);
 	}
 
+	/**
+	 * Single-argument twin of `callHooksForName` (must stay in sync with
+	 * `_callHooksForInfo`): every internal dispatch passes exactly one hook
+	 * argument, so this skips the rest-array collection and spread call the
+	 * generic path pays per identifier.
+	 * @template T
+	 * @template R
+	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks that should be called
+	 * @param {string} name key in map
+	 * @param {AsArray<T>[0]} arg the single hook argument
+	 * @returns {R | undefined} result of hook
+	 */
+	_callHooksForName1(hookMap, name, arg) {
+		return this._callHooksForInfo1(hookMap, this.getVariableInfo(name), arg);
+	}
+
+	/**
+	 * Single-argument twin of `callHooksForInfo` (must stay in sync with
+	 * `_callHooksForInfo`), for the hot dispatch sites that pass one argument
+	 * and no fallback/defined callbacks.
+	 * @template T
+	 * @template R
+	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks that should be called
+	 * @param {ExportedVariableInfo} info variable info
+	 * @param {AsArray<T>[0]} arg the single hook argument
+	 * @returns {R | undefined} result of hook
+	 */
+	_callHooksForInfo1(hookMap, info, arg) {
+		/** @type {string} */
+		let name;
+		if (typeof info === "string") {
+			name = info;
+		} else {
+			if (!(info instanceof VariableInfo)) {
+				return;
+			}
+			let tagInfo = info.tagInfo;
+			while (tagInfo !== undefined) {
+				const hook =
+					/** @type {SyncBailHook<[AsArray<T>[0]], R> | undefined} */
+					(hookMap.get(tagInfo.tag));
+				if (hook !== undefined) {
+					this.currentTagData = tagInfo.data;
+					const result = hook.call(arg);
+					this.currentTagData = undefined;
+					if (result !== undefined) return result;
+				}
+				tagInfo = tagInfo.next;
+			}
+			if (!info.isFree() && !info.isTagged()) {
+				return;
+			}
+			name = /** @type {string} */ (info.name);
+		}
+		const hook =
+			/** @type {SyncBailHook<[AsArray<T>[0]], R> | undefined} */
+			(hookMap.get(name));
+		if (hook !== undefined) {
+			const result = hook.call(arg);
+			if (result !== undefined) return result;
+		}
+	}
+
 	/**
 	 * Processes the provided param.
 	 * @deprecated
@@ -4971,26 +5808,8 @@ class JavascriptParser extends Parser {
 	 * @returns {void}
 	 */
 	inFunctionScope(hasThis, params, fn) {
-		const oldScope = this.scope;
-		this.scope = {
-			topLevelScope: oldScope.topLevelScope,
-			inTry: false,
-			inShorthand: false,
-			inTaggedTemplateTag: false,
-			isStrict: oldScope.isStrict,
-			isAsmJs: oldScope.isAsmJs,
-			terminated: undefined,
-			definitions: oldScope.definitions.createChild()
-		};
-
-		if (hasThis) {
-			this.undefineVariable("this");
-		}
-
-		this.enterPatterns(params, this._defineVariable);
-
+		const oldScope = this._enterFunctionScope(hasThis, params);
 		fn();
-
 		this.scope = oldScope;
 	}
 
@@ -5001,6 +5820,18 @@ class JavascriptParser extends Parser {
 	 * @returns {void}
 	 */
 	inBlockScope(fn, inExecutedPath = false) {
+		const oldScope = this._enterBlockScope();
+		fn();
+		this._exitBlockScope(oldScope, inExecutedPath);
+	}
+
+	/**
+	 * Enters a fresh block scope: the closure-free core of `inBlockScope`, used
+	 * directly by the internal walkers so each block does not allocate a
+	 * closure and context. Pass the returned scope to `_exitBlockScope`.
+	 * @returns {ScopeInfo} the previous scope
+	 */
+	_enterBlockScope() {
 		const oldScope = this.scope;
 		this.scope = {
 			topLevelScope: oldScope.topLevelScope,
@@ -5012,18 +5843,50 @@ class JavascriptParser extends Parser {
 			terminated: oldScope.terminated,
 			definitions: oldScope.definitions.createChild()
 		};
+		return oldScope;
+	}
 
-		fn();
-
+	/**
+	 * Leaves a block scope entered with `_enterBlockScope`.
+	 * @param {ScopeInfo} oldScope scope returned by `_enterBlockScope`
+	 * @param {boolean} inExecutedPath whether termination propagates to the outer scope
+	 * @returns {void}
+	 */
+	_exitBlockScope(oldScope, inExecutedPath) {
 		const terminated = this.scope.terminated;
-
 		if (inExecutedPath && terminated) {
 			oldScope.terminated = terminated;
 		}
-
 		this.scope = oldScope;
 	}
 
+	/**
+	 * Enters a fresh function scope: the closure-free core of `inFunctionScope`,
+	 * used directly by the internal walkers. Restore `this.scope` to the
+	 * returned scope when leaving.
+	 * @param {boolean} hasThis true, when this is defined
+	 * @param {(Pattern | string)[]} params scope params
+	 * @returns {ScopeInfo} the previous scope
+	 */
+	_enterFunctionScope(hasThis, params) {
+		const oldScope = this.scope;
+		this.scope = {
+			topLevelScope: oldScope.topLevelScope,
+			inTry: false,
+			inShorthand: false,
+			inTaggedTemplateTag: false,
+			isStrict: oldScope.isStrict,
+			isAsmJs: oldScope.isAsmJs,
+			terminated: undefined,
+			definitions: oldScope.definitions.createChild()
+		};
+		if (hasThis) {
+			this.undefineVariable("this");
+		}
+		this.enterPatterns(params, this._defineVariable);
+		return oldScope;
+	}
+
 	/**
 	 * Processes the provided statement.
 	 * @param {(Directive | Statement | ModuleDeclaration)[]} statements statements
@@ -5103,7 +5966,7 @@ class JavascriptParser extends Parser {
 	 * @param {OnIdent} onIdent callback
 	 */
 	enterIdentifier(pattern, onIdent) {
-		if (!this.callHooksForName(this.hooks.pattern, pattern.name, pattern)) {
+		if (!this._callHooksForName1(this.hooks.pattern, pattern.name, pattern)) {
 			onIdent(pattern.name, pattern);
 		}
 	}
@@ -5351,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 =
@@ -5398,16 +6268,19 @@ 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;
 		}
 		this.hooks.finish.call(ast, comments);
+		this._releaseMemberExpression();
 		this.scope = oldScope;
 		this.state = oldState;
 		this.comments = oldComments;
@@ -5418,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;
 	}
 
@@ -5452,6 +6326,9 @@ class JavascriptParser extends Parser {
 				`(${source})`,
 				{
 					sourceType: this.sourceType,
+					// ranges alone take the lazy path, which serves `range` from a
+					// getter and tracks no locations — as the module parse does
+					ranges: true,
 					importPhases
 				},
 				this.options.parse
@@ -5533,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];
@@ -5590,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" ||
@@ -5614,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) &&
@@ -5753,7 +6625,15 @@ class JavascriptParser extends Parser {
 				};
 			}
 		}
-		return /** @type {DependencyLocation} */ (node.loc);
+		const loc = node.loc;
+		if (!loc) {
+			return /** @type {DependencyLocation} */ (/** @type {unknown} */ (loc));
+		}
+		// a plain copy: a foreign parser's location class must not reach the cache
+		return {
+			start: { line: loc.start.line, column: loc.start.column },
+			end: { line: loc.end.line, column: loc.end.column }
+		};
 	}
 
 	/**
@@ -5768,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
@@ -5995,6 +6915,7 @@ class JavascriptParser extends Parser {
 			});
 		}
 		this.scope.definitions.set(name, newInfo);
+		this._memberExpression = undefined;
 	}
 
 	/**
@@ -6011,6 +6932,7 @@ class JavascriptParser extends Parser {
 			return;
 		}
 		this.scope.definitions.set(name, this.scope);
+		this._memberExpression = undefined;
 	}
 
 	/**
@@ -6019,6 +6941,7 @@ class JavascriptParser extends Parser {
 	 */
 	undefineVariable(name) {
 		this.scope.definitions.delete(name);
+		this._memberExpression = undefined;
 	}
 
 	/**
@@ -6071,6 +6994,7 @@ class JavascriptParser extends Parser {
 	 * @returns {void}
 	 */
 	setVariable(name, variableInfo) {
+		this._memberExpression = undefined;
 		if (typeof variableInfo === "string") {
 			if (variableInfo === name) {
 				this.scope.definitions.delete(name);
@@ -6242,69 +7166,219 @@ class JavascriptParser extends Parser {
 	/** @typedef {{ type: "expression", rootInfo: string | VariableInfo, name: string, getMembers: () => Members, getMembersOptionals: () => MembersOptionals, getMemberRanges: () => MemberRanges }} ExpressionExpressionInfo */
 
 	/**
-	 * Gets member expression info.
+	 * Resolves a member expression into the `_member*` slots, once per node and
+	 * scope. Returns 0 when rejected, 1 for an `expression`, 2 for a `call`.
 	 * @param {Expression | Super} expression a member expression
-	 * @param {number} allowedTypes which types should be returned, presented in bit mask
-	 * @returns {CallExpressionInfo | ExpressionExpressionInfo | undefined} expression info
+	 * @param {number} allowedTypes which types may be returned, presented in bit mask
+	 * @returns {0 | 1 | 2} the kind resolved
 	 */
-	getMemberExpressionInfo(expression, allowedTypes) {
+	_resolveMemberExpression(expression, allowedTypes) {
+		if (
+			expression === this._memberExpression &&
+			this._memberScope === this.scope
+		) {
+			const type = this._memberType;
+			if (type !== 0) {
+				// the root kind is a fact of the node; the mask only says whether to report it
+				const bit =
+					type === 2
+						? ALLOWED_MEMBER_TYPES_CALL_EXPRESSION
+						: ALLOWED_MEMBER_TYPES_EXPRESSION;
+				return (allowedTypes & bit) === 0 ? 0 : type;
+			}
+			if ((allowedTypes & ~this._memberMask) === 0) return 0;
+		}
+		this._memberExpression = expression;
+		this._memberScope = this.scope;
+		this._memberMask = allowedTypes;
+		this._memberType = 0;
+		this._memberInfo = undefined;
 		// Resolve the root first (no allocation); most calls reject here and so
-		// never build the member arrays via extractMemberExpressionChain.
+		// never build the member arrays
 		const object = this.getMemberExpressionRoot(expression);
 		switch (object.type) {
 			case "CallExpression": {
-				if ((allowedTypes & ALLOWED_MEMBER_TYPES_CALL_EXPRESSION) === 0) return;
+				if ((allowedTypes & ALLOWED_MEMBER_TYPES_CALL_EXPRESSION) === 0) {
+					return 0;
+				}
 				const calleeExpr = object.callee;
 				const callee =
 					calleeExpr.type === "MemberExpression"
 						? this.getMemberExpressionRoot(calleeExpr)
 						: calleeExpr;
 				const rootName = getRootName(callee);
-				if (!rootName) return;
-				const result = this.getNameInfoFromVariable(rootName);
-				if (!result) return;
-				const { info: rootInfo, name: resolvedRoot } = result;
-				const rootMembers =
-					calleeExpr.type === "MemberExpression"
-						? this.extractMemberExpressionChain(calleeExpr).members
-						: EMPTY_ARRAY;
-				const { members, membersOptionals, memberRanges } =
-					this.extractMemberExpressionChain(expression);
+				if (!rootName) return this._rejectMemberExpression();
+				const resolvedRoot = this._resolveMemberRoot(rootName);
+				if (resolvedRoot === undefined) return this._rejectMemberExpression();
+				/** @type {CalleeMembers} */
+				let rootMembers = EMPTY_ARRAY;
+				if (calleeExpr.type === "MemberExpression") {
+					this._extractMembers(calleeExpr);
+					rootMembers = this._members;
+				}
+				this._extractMembers(expression);
 				const calleeName = objectAndMembersToName(resolvedRoot, rootMembers);
-				return {
-					type: "call",
-					call: object,
-					calleeName,
-					rootInfo,
-					getCalleeMembers: lazyReverse(rootMembers),
-					name: objectAndMembersToName(`${calleeName}()`, members),
-					getMembers: lazyReverse(members),
-					getMembersOptionals: lazyReverse(membersOptionals),
-					getMemberRanges: lazyReverse(memberRanges)
-				};
+				this._memberType = 2;
+				this._memberCall = object;
+				this._memberCalleeName = calleeName;
+				this._memberCalleeMembers = rootMembers;
+				this._memberName = objectAndMembersToName(
+					`${calleeName}()`,
+					this._members
+				);
+				return 2;
 			}
 			case "Identifier":
 			case "MetaProperty":
 			case "ThisExpression": {
-				if ((allowedTypes & ALLOWED_MEMBER_TYPES_EXPRESSION) === 0) return;
+				if ((allowedTypes & ALLOWED_MEMBER_TYPES_EXPRESSION) === 0) return 0;
 				const rootName = getRootName(object);
-				if (!rootName) return;
+				if (!rootName) return this._rejectMemberExpression();
+				const resolvedRoot = this._resolveMemberRoot(rootName);
+				if (resolvedRoot === undefined) return this._rejectMemberExpression();
+				this._extractMembers(expression);
+				this._memberType = 1;
+				this._memberName = objectAndMembersToName(resolvedRoot, this._members);
+				return 1;
+			}
+		}
+		return this._rejectMemberExpression();
+	}
 
-				const result = this.getNameInfoFromVariable(rootName);
-				if (!result) return;
-				const { info: rootInfo, name: resolvedRoot } = result;
-				const { members, membersOptionals, memberRanges } =
-					this.extractMemberExpressionChain(expression);
-				return {
-					type: "expression",
-					name: objectAndMembersToName(resolvedRoot, members),
-					rootInfo,
-					getMembers: lazyReverse(members),
-					getMembersOptionals: lazyReverse(membersOptionals),
-					getMemberRanges: lazyReverse(memberRanges)
-				};
+	/**
+	 * Records that the node resolves to nothing under any mask.
+	 * @returns {0} rejected
+	 */
+	_rejectMemberExpression() {
+		this._memberMask = ALLOWED_MEMBER_TYPES_ALL;
+		return 0;
+	}
+
+	/**
+	 * `getNameInfoFromVariable` for the resolver: stores the info in
+	 * `_memberRootInfo` and returns the name, or undefined when rejected.
+	 * @param {string} rootName name of the root variable
+	 * @returns {string | undefined} the resolved root name
+	 */
+	_resolveMemberRoot(rootName) {
+		const info = this.getVariableInfo(rootName);
+		if (info instanceof VariableInfo && info.name) {
+			if (!info.isFree() && !info.isTagged()) return;
+			this._memberRootInfo = info;
+			return info.name;
+		}
+		if (typeof info !== "string") return;
+		this._memberRootInfo = info;
+		return info;
+	}
+
+	/**
+	 * Fills `_members` and `_membersOptionals` for the chain, in source order.
+	 * @param {Expression | Super} expression a member expression
+	 * @returns {void}
+	 */
+	_extractMembers(expression) {
+		/** @type {Node} */
+		let expr = expression;
+		/** @type {Members} */
+		const members = [];
+		/** @type {MembersOptionals} */
+		const membersOptionals = [];
+		while (expr.type === "MemberExpression") {
+			if (expr.computed) {
+				const prop = expr.property;
+				if (prop.type === "Literal") {
+					members.push(`${prop.value}`);
+				} else if (
+					prop.type === "TemplateLiteral" &&
+					prop.expressions.length === 0 &&
+					typeof prop.quasis[0].value.cooked === "string"
+				) {
+					members.push(prop.quasis[0].value.cooked);
+				} else {
+					break;
+				}
+			} else {
+				if (expr.property.type !== "Identifier") break;
+				members.push(expr.property.name);
 			}
+			membersOptionals.push(expr.optional);
+			expr = expr.object;
+		}
+		if (members.length > 1) {
+			members.reverse();
+			membersOptionals.reverse();
+		}
+		this._members = members;
+		this._membersOptionals = membersOptionals;
+	}
+
+	/**
+	 * Drops the resolved member expression, so no AST outlives its parse.
+	 * @returns {void}
+	 */
+	_releaseMemberExpression() {
+		this._memberExpression = undefined;
+		this._memberScope = undefined;
+		this._memberType = 0;
+		this._memberRootInfo = undefined;
+		this._members = EMPTY_ARRAY;
+		this._membersOptionals = EMPTY_MEMBERS_OPTIONALS;
+		this._memberCall = undefined;
+		this._memberCalleeMembers = EMPTY_ARRAY;
+		this._memberInfo = undefined;
+	}
+
+	/**
+	 * Gets member expression info.
+	 * @param {Expression | Super} expression a member expression
+	 * @param {number} allowedTypes which types should be returned, presented in bit mask
+	 * @returns {CallExpressionInfo | ExpressionExpressionInfo | undefined} expression info
+	 */
+	getMemberExpressionInfo(expression, allowedTypes) {
+		const type = this._resolveMemberExpression(expression, allowedTypes);
+		if (type === 0) return;
+		const cached = this._memberInfo;
+		if (cached !== undefined) return cached;
+		const members = this._members;
+		const membersOptionals = this._membersOptionals;
+		/** @type {MemberRanges | undefined} */
+		let memberRanges;
+		const getMembers = () => members;
+		const getMembersOptionals = () => membersOptionals;
+		const getMemberRanges = () =>
+			memberRanges ||
+			(memberRanges = memberRangesOf(expression, members.length));
+		const rootInfo = /** @type {string | VariableInfo} */ (
+			this._memberRootInfo
+		);
+		/** @type {CallExpressionInfo | ExpressionExpressionInfo} */
+		let info;
+		if (type === 2) {
+			const calleeMembers = this._memberCalleeMembers;
+			info = {
+				type: "call",
+				call: /** @type {CallExpression} */ (this._memberCall),
+				calleeName: this._memberCalleeName,
+				rootInfo,
+				getCalleeMembers: () => calleeMembers,
+				name: this._memberName,
+				getMembers,
+				getMembersOptionals,
+				getMemberRanges
+			};
+		} else {
+			info = {
+				type: "expression",
+				name: this._memberName,
+				rootInfo,
+				getMembers,
+				getMembersOptionals,
+				getMemberRanges
+			};
 		}
+		this._memberInfo = info;
+		return info;
 	}
 
 	/**
@@ -6373,7 +7447,10 @@ class JavascriptParser extends Parser {
 			// syntax so `auto` avoids a second full parse in the common case
 			parserOptions.moduleFallback = type === "auto";
 		}
-		const wantRanges = parserOptions.ranges === true;
+		// `locations` are acorn's to track, so the lazy path serves the callers
+		// that ask for ranges alone — which is every one inside webpack
+		const wantLazyNodes =
+			parserOptions.ranges === true && parserOptions.locations !== true;
 		/**
 		 * Returns parse result.
 		 * @param {string} code source code
@@ -6388,34 +7465,27 @@ class JavascriptParser extends Parser {
 			/** @type {Comment[]} */
 			const comments = [];
 
-			// Whenever ranges are wanted (the main parse path and the concatenation
-			// re-parse), have the parser plugin serve `range` on demand instead of
-			// eagerly. `wantRanges` is hoisted since the auto-fallback re-enters
-			// with the same (mutated) options object.
-			options.lazyNodes = wantRanges;
-			if (wantRanges) {
+			// Ranges alone (the main parse path and the concatenation re-parse) are
+			// served on demand; hoisted, since the auto-fallback re-enters here.
+			options.lazyNodes = wantLazyNodes;
+			if (wantLazyNodes) {
 				// the lazy plugin replaces acorn's native tracking — disabling it
 				// here lets WebpackParser skip its defensive options copy
-				options.locations = false;
 				options.ranges = false;
 			}
 
 			if (options.comments) {
-				if (wantRanges) {
+				if (wantLazyNodes) {
 					// the parser plugin collects the comments itself, deferring the
 					// text slice until some hook actually reads `value`
 					options.lazyComments = comments;
 				} else {
-					/** @type {AcornOptions} */
-					(options).onComment =
-						/** @type {import("acorn").Comment[]} */
-						(/** @type {unknown} */ (comments));
+					/** @type {ParserOptions} */
+					(options).onComment = comments;
 				}
 			}
 
-			const ast =
-				/** @type {Program} */
-				(parser.parse(code, /** @type {AcornOptions} */ (options)));
+			const ast = /** @type {Program} */ (parser.parse(code, options));
 
 			return { ast, comments };
 		};
@@ -6451,7 +7521,7 @@ class JavascriptParser extends Parser {
 		// release per-parse state retained on the (possibly reused) options
 		// object — the comments array retains source text slices
 		parserOptions.lazyComments = undefined;
-		/** @type {AcornOptions} */
+		/** @type {ParserOptions} */
 		(parserOptions).onComment = undefined;
 
 		if (threw) {
@@ -6463,7 +7533,7 @@ class JavascriptParser extends Parser {
 
 	/**
 	 * Returns parser.
-	 * @param {((BaseParser: AcornParser) => AcornParser)[]} plugins parser plugin
+	 * @param {ParserPlugin[]} plugins parser plugin
 	 * @returns {typeof JavascriptParser} parser
 	 */
 	static extend(...plugins) {