webpack 5.110.2 → 5.111.0

package/lib/javascript/JavascriptParser.js

@@ -26,13 +26,7 @@ const {
 	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,
@@ -151,25 +145,8 @@ const {
 
 /** @type {string[]} */
 const EMPTY_ARRAY = [];
-
-/**
- * Getter that reverses `arr` in place on first access and caches it. Lighter
- * than `memoize(() => arr.reverse())` (one closure instead of two) and called
- * per member expression on hot parse paths.
- * @template T
- * @param {T[]} arr array reversed lazily on first access
- * @returns {() => T[]} getter returning the reversed array
- */
-const lazyReverse = (arr) => {
-	let reversed = false;
-	return () => {
-		if (!reversed) {
-			arr.reverse();
-			reversed = true;
-		}
-		return arr;
-	};
-};
+/** @type {MembersOptionals} */
+const EMPTY_MEMBERS_OPTIONALS = [];
 
 const ALLOWED_MEMBER_TYPES_CALL_EXPRESSION = 0b01;
 const ALLOWED_MEMBER_TYPES_EXPRESSION = 0b10;
@@ -183,8 +160,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 +307,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
@@ -430,24 +410,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),
@@ -802,6 +1213,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 +1246,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 +1320,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,277 +1432,9 @@ 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 === "+") {
 				const left = this.evaluateExpression(expr.left);
 				const right = this.evaluateExpression(expr.right);
@@ -1416,41 +1601,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 +1651,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 +1663,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 +1749,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 +1792,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 +1868,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 +1902,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
@@ -2504,13 +2673,14 @@ class JavascriptParser extends Parser {
 	 * @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.blockPreWalkStatements(body);
+		this.prevStatement = prev;
+		this.walkStatements(body);
+
+		this._exitBlockScope(oldScope, true);
 	}
 
 	/**
@@ -2562,18 +2732,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;
@@ -2607,9 +2786,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);
+
+		this._exitBlockScope(oldScope, false);
 	}
 
 	/**
@@ -2631,10 +2811,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);
+
+		this._exitBlockScope(oldScope, false);
 	}
 
 	/**
@@ -2747,10 +2928,11 @@ class JavascriptParser extends Parser {
 	 * @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);
+
+		this._exitBlockScope(oldScope, false);
 	}
 
 	/**
@@ -2766,10 +2948,11 @@ class JavascriptParser extends Parser {
 	 * @param {DoWhileStatement} statement do while statement
 	 */
 	walkDoWhileStatement(statement) {
-		this.inBlockScope(() => {
-			this.walkNestedStatement(statement.body);
-			this.walkExpression(statement.test);
-		});
+		const oldScope = this._enterBlockScope();
+		this.walkNestedStatement(statement.body);
+		this.walkExpression(statement.test);
+
+		this._exitBlockScope(oldScope, false);
 	}
 
 	/**
@@ -2788,35 +2971,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 oldScope = this._enterBlockScope();
+		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;
+		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.blockPreWalkStatements(body.body);
+			this.prevStatement = prev;
+			this.walkStatements(body.body);
+		} else {
+			this.walkNestedStatement(body);
+		}
+
+		this._exitBlockScope(oldScope, false);
 	}
 
 	/**
@@ -2835,28 +3019,29 @@ 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 {
+			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.blockPreWalkStatements(body.body);
+			this.prevStatement = prev;
+			this.walkStatements(body.body);
+		} else {
+			this.walkNestedStatement(body);
+		}
+
+		this._exitBlockScope(oldScope, false);
 	}
 
 	/**
@@ -2878,28 +3063,29 @@ class JavascriptParser extends Parser {
 	 * @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);
-			}
+		const oldScope = this._enterBlockScope();
+		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.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.blockPreWalkStatements(body.body);
+			this.prevStatement = prev;
+			this.walkStatements(body.body);
+		} else {
+			this.walkNestedStatement(body);
+		}
+
+		this._exitBlockScope(oldScope, false);
 	}
 
 	/**
@@ -2925,19 +3111,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.preWalkStatement(statement.body);
+		this.prevStatement = prev;
+		this.walkStatement(statement.body);
+
+		this.scope = oldScope;
 		this.scope.topLevelScope = wasTopLevel;
 	}
 
@@ -3303,7 +3490,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 +3501,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 +3641,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 =
@@ -3523,40 +3714,35 @@ class JavascriptParser extends Parser {
 	 * @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.blockPreWalkStatements(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;
 			}
-		});
+		}
+
+		this._exitBlockScope(oldScope, false);
 	}
 
 	/**
@@ -3572,22 +3758,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 +4072,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.preWalkStatement(expression.body);
+		this.prevStatement = prev;
+		this.walkStatement(expression.body);
+
+		this.scope = oldScope;
 		this.scope.topLevelScope = wasTopLevel;
 	}
 
@@ -3911,20 +4099,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.preWalkStatement(expression.body);
+			this.prevStatement = prev;
+			this.walkStatement(expression.body);
+		} else {
+			this.walkExpression(expression.body);
+		}
+
+		this.scope = oldScope;
 		this.scope.topLevelScope = wasTopLevel;
 	}
 
@@ -4185,7 +4374,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 +4382,7 @@ class JavascriptParser extends Parser {
 			) {
 				// renaming "a = b;"
 				if (
-					!this.callHooksForInfo(
+					!this._callHooksForInfo1(
 						this.hooks.rename,
 						renameIdentifier,
 						expression.right
@@ -4209,34 +4398,42 @@ 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.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 +4458,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 +4581,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 +4628,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.preWalkStatement(functionExpression.body);
+			this.prevStatement = prev;
+			this.walkStatement(functionExpression.body);
+		} else {
+			this.walkExpression(functionExpression.body);
+		}
+
+		this.scope = oldScope;
 		this.scope.topLevelScope = wasTopLevel;
 	}
 
@@ -4553,22 +4760,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),
@@ -4597,68 +4808,112 @@ class JavascriptParser extends Parser {
 	 * @param {MemberExpression} expression member expression
 	 */
 	walkMemberExpression(expression) {
-		const exprInfo = this.getMemberExpressionInfo(
+		const type = this._resolveMemberExpression(
 			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;
-				}
+		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}
+	 */
+	_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);
+		}
+		if (expression.computed === true) this.walkExpression(expression.property);
+	}
+
 	/**
 	 * Walk member expression with expression name.
 	 * @template R
@@ -4684,7 +4939,7 @@ class JavascriptParser extends Parser {
 			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 +4963,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 +4971,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 +5137,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 +5179,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 +5310,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 +5322,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 +5345,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 +5468,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);
 		}
 	}
@@ -5408,6 +5773,7 @@ class JavascriptParser extends Parser {
 			this.destructuringAssignmentProperties = undefined;
 		}
 		this.hooks.finish.call(ast, comments);
+		this._releaseMemberExpression();
 		this.scope = oldScope;
 		this.state = oldState;
 		this.comments = oldComments;
@@ -5452,6 +5818,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
@@ -5753,7 +6122,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 }
+		};
 	}
 
 	/**
@@ -5995,6 +6372,7 @@ class JavascriptParser extends Parser {
 			});
 		}
 		this.scope.definitions.set(name, newInfo);
+		this._memberExpression = undefined;
 	}
 
 	/**
@@ -6011,6 +6389,7 @@ class JavascriptParser extends Parser {
 			return;
 		}
 		this.scope.definitions.set(name, this.scope);
+		this._memberExpression = undefined;
 	}
 
 	/**
@@ -6019,6 +6398,7 @@ class JavascriptParser extends Parser {
 	 */
 	undefineVariable(name) {
 		this.scope.definitions.delete(name);
+		this._memberExpression = undefined;
 	}
 
 	/**
@@ -6071,6 +6451,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 +6623,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 +6904,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 +6922,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 +6978,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 +6990,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) {