webpack 5.111.0 → 5.111.1

package/lib/javascript/syntax.js

@@ -27,6 +27,9 @@ const {
 /** @type {typeof import("./grammar").Grammar} */
 const BaseParser = /** @type {EXPECTED_ANY} */ (Parser);
 
+/** @typedef {EXPECTED_ANY[]} HoistedDeclarations the declarations one scope hoists, in source order */
+/** @typedef {EXPECTED_ANY[]} 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 passes `MAX_MASKED_INDEX` */
 /** @typedef {{ token: string, isExpr: boolean, preserveSpace?: boolean, generator?: boolean, override?: unknown }} TokContextShim the TokContext fields the owned tokenizer reads */
 
 // the token contexts used by the inlined finishToken context updates
@@ -93,10 +96,9 @@ const stringToBigInt = (str) => BigInt(str.replace(/_/g, ""));
 /** @typedef {CollectedComment[] | ((isBlock: boolean, text: string, start: number, end: number) => void)} CommentSink where comments are collected, as an array or a callback */
 /** @typedef {Omit<Options, "onComment"> & { onComment?: CommentSink, lazyNodes?: boolean, lazyComments?: CollectedComment[], importPhases?: boolean, moduleFallback?: boolean }} ParserOptions the parser's options, carrying webpack's own comment type plus its lazy-node and import-phase switches */
 
-// Symbol-keyed so they stay out of for-in, Object.keys and JSON.stringify
-// over AST nodes.
-// Per-TokContext "the owned token loop must step aside" flag, cached on the
-// context itself so the hot guard reads one slot instead of two.
+// Symbol-keyed so they stay out of for-in, Object.keys and JSON.stringify over
+// AST nodes. `kSlowContext` is the per-TokContext "step aside" flag, cached on
+// the context so the hot guard reads one slot rather than two.
 const kSlowContext = Symbol("slow context");
 const kSource = Symbol("source");
 const kRange = Symbol("range");
@@ -146,11 +148,9 @@ IDENT_START[95] = 1;
 for (let i = 65; i <= 90; i++) IDENT_START[i] = 1;
 for (let i = 97; i <= 122; i++) IDENT_START[i] = 1;
 
-// Single-char punctuators that acorn's `getTokenFromCode` reads as just
-// `++pos; finishToken(type)` (no value, no operator state machine). Dispatching
-// them from `nextToken`'s char table skips the extra `getTokenFromCode` call and
-// its switch for the commonest tokens in JS ( ) { } [ ] ; , : — `0` is "not a
-// simple punctuator" since token types are truthy objects.
+// Single-char punctuators acorn reads as just `++pos; finishToken(type)`, with
+// no value and no operator state machine. Dispatching them from `nextToken`'s
+// char table skips a call and a switch for the commonest tokens in JS.
 const SIMPLE_PUNCT = Array.from({ length: 128 });
 SIMPLE_PUNCT[40] = tokTypes.parenL;
 SIMPLE_PUNCT[41] = tokTypes.parenR;
@@ -162,10 +162,9 @@ SIMPLE_PUNCT[123] = tokTypes.braceL;
 SIMPLE_PUNCT[125] = tokTypes.braceR;
 SIMPLE_PUNCT[58] = tokTypes.colon;
 
-// Characters that can only start a token which cannot continue an expression,
-// so an atom directly followed by one is the whole expression (see
-// `parseMaybeAssign`'s fast path). `}` included: it only ever closes a block,
-// an object or a template substitution.
+// Characters starting only a token that cannot continue an expression, so an
+// atom directly followed by one is the whole expression. `}` is included: it
+// only ever closes a block, an object or a template substitution.
 const EXPRESSION_END_CHAR = new Uint8Array(128);
 EXPRESSION_END_CHAR[41] = 1; // )
 EXPRESSION_END_CHAR[44] = 1; // ,
@@ -186,10 +185,9 @@ const CLS_UNICODE = 5;
 const CLS_SPACE = 6;
 const CLS_NEWLINE = 7;
 const CLS_SLASH = 8;
-// Full `charCodeAt` range so the scan loop needs no `code > 127` branch per
-// character: every non-ASCII code unit classifies as CLS_UNICODE (which sorts
-// below CLS_SPACE, so the loop exits on the same single compare) and the
-// dispatch delegates it to acorn's unicode-aware paths.
+// Covers the whole `charCodeAt` range, so the scan loop needs no `code > 127`
+// branch: non-ASCII classifies as CLS_UNICODE, which sorts below CLS_SPACE and
+// so exits on the same compare, then delegates to acorn's unicode paths.
 const CHAR_CLASS = new Uint8Array(0x10000).fill(CLS_UNICODE, 128);
 for (let i = 0; i < 128; i++) {
 	if (IDENT_START[i] === 1 || i === 92) CHAR_CLASS[i] = CLS_IDENT;
@@ -410,6 +408,78 @@ class UnaryNode {
 	}
 }
 
+// WHY: a sparse symbol slot, not a field: the list is webpack's own record of
+// the scope, and a named key would land in every consumer's view of the AST —
+// `JSON.stringify` included, where it duplicates each declaration's subtree.
+const HOISTED_DECLARATIONS = Symbol("hoistedDeclarations");
+
+// The slot of a scope that declared nothing. It has to differ from the empty
+// slot of a node some other parser built, which has no record to read.
+/** @type {HoistedDeclarations} */
+const NO_HOISTED_DECLARATIONS = [];
+
+// The program's own import and re-export declarations, read before anything
+// else — same sparse-slot reasoning as the hoisted list above.
+const MODULE_DECLARATIONS = Symbol("moduleDeclarations");
+
+/** @type {ModuleDeclarations} */
+const NO_MODULE_DECLARATIONS = [];
+
+// Which statements of one list declare into its own block scope, read before
+// any of it is walked — same sparse-slot reasoning as the two lists above. It
+// holds their indices, so `undefined` alone means no record was kept.
+const BLOCK_DECLARATIONS = Symbol("blockDeclarations");
+
+// WHY: the indices live in one number rather than an array because 59.4% of the
+// lists that declare anything declare exactly once, and a 4-element array costs
+// ~200 bytes of V8 overhead — 2.33 MB of an 84 MB AST measured over the
+// `js-parser-unit` sources. Only an index past this one needs the array.
+const MAX_MASKED_INDEX = 30;
+
+/**
+ * Turn a mask that can no longer hold every index into the list it falls back
+ * to, holding what the mask held plus the index that overflowed it.
+ * @param {number} mask the indices recorded so far
+ * @param {number} index the index that does not fit
+ * @returns {number[]} every index, in source order
+ */
+const overflowFrom = (mask, index) => {
+	/** @type {number[]} */
+	const indices = [];
+	for (let bits = mask; bits !== 0; bits &= bits - 1) {
+		indices.push(31 - Math.clz32(bits & -bits));
+	}
+	indices.push(index);
+	return indices;
+};
+
+/**
+ * Whether a statement declares anything into the block scope holding it, which
+ * is what the consumer reads the list for.
+ * @param {EXPECTED_ANY} statement the finished statement
+ * @returns {boolean} whether it belongs in the list
+ */
+const declaresIntoBlock = (statement) => {
+	const type = statement.type;
+	if (
+		type === "VariableDeclaration" ||
+		type === "ClassDeclaration" ||
+		type === "ExportNamedDeclaration" ||
+		type === "ExportDefaultDeclaration"
+	) {
+		return true;
+	}
+	// WHY: only an assignment to an object pattern is read here, for the
+	// properties it names. Keeping every expression statement would carry the
+	// most common statement there is: 10390 of three-long's 22758, against 1.
+	if (type !== "ExpressionStatement") return false;
+	const expression = statement.expression;
+	return (
+		expression.type === "AssignmentExpression" &&
+		expression.left.type === "ObjectPattern"
+	);
+};
+
 /**
  * Single-shape `VariableDeclaration` (statement position; `for` heads keep the
  * generic node since their caller finishes them).
@@ -480,6 +550,11 @@ class BlockStatementNode {
 		this.start = start;
 		this.end = end;
 		this.body = body;
+		// filled for a function body only: what hoists to the scope it opens
+		/** @type {HoistedDeclarations | undefined} */
+		this[HOISTED_DECLARATIONS] = undefined;
+		/** @type {BlockDeclarations | undefined} */
+		this[BLOCK_DECLARATIONS] = undefined;
 	}
 }
 
@@ -784,6 +859,8 @@ class SwitchCaseNode {
 		this.consequent = null;
 		/** @type {Expression | null} */
 		this.test = null;
+		/** @type {BlockDeclarations | undefined} */
+		this[BLOCK_DECLARATIONS] = undefined;
 	}
 }
 
@@ -995,6 +1072,8 @@ class StaticBlockNode {
 		this.end = 0;
 		/** @type {Node[] | null} */
 		this.body = null;
+		/** @type {BlockDeclarations | undefined} */
+		this[BLOCK_DECLARATIONS] = undefined;
 	}
 }
 
@@ -1337,6 +1416,12 @@ class ProgramNode {
 		this.end = end;
 		this.body = body;
 		this.sourceType = sourceType;
+		/** @type {HoistedDeclarations | undefined} */
+		this[HOISTED_DECLARATIONS] = undefined;
+		/** @type {ModuleDeclarations | undefined} */
+		this[MODULE_DECLARATIONS] = undefined;
+		/** @type {BlockDeclarations | undefined} */
+		this[BLOCK_DECLARATIONS] = undefined;
 	}
 }
 
@@ -1727,6 +1812,10 @@ class LazyComment {
  * lineStart: number,
  * _scopePool: Scope[],
  * _setPool: Set<string>[],
+ * _exportHeadDepth: number,
+ * _exitedHoisted: HoistedDeclarations | undefined,
+ * _moduleDeclarations: ModuleDeclarations | undefined,
+ * _previousTopLevelStatement: Node | undefined,
  * _takeSet: () => Set<string>,
  * _labelsStack: { kind?: string | null, name?: string, statementStart?: number }[][],
  * _labelsDepth: number,
@@ -1830,10 +1919,9 @@ const wordLookupsCache = new Map();
 // parser constructor, so the hot paths never observe the nulls behind it.
 const NO_CACHE = /** @type {EXPECTED_ANY} */ (null);
 
-// Direct-mapped identifier cache for `readWord1`: one slot per hash, verified
-// by char compare, overwritten on collision. Shared across parses — hits are
-// content-checked, so a stale entry is merely a miss. Only words short enough
-// to be flat V8 strings (never slices retaining their whole source) are stored.
+// Direct-mapped identifier cache for `readWord1`: one slot per hash, verified by
+// char compare, overwritten on collision. Shared across parses, since a hit is
+// content-checked. Only lengths V8 stores flat, never source-retaining slices.
 const WORD_CACHE_MASK = 0xfff;
 const WORD_CACHE_MAX_LEN = 12;
 
@@ -1844,12 +1932,13 @@ let WORD_CACHE = NO_CACHE;
 const WORD_CACHE_STRIDE = 4;
 let nextWordLookupsId = 1;
 
-// Direct-mapped cache for short non-word slices, WORD_CACHE's regime applied
-// to literal text: number raws repeat heavily (a typical large input has ~10x
-// more number literals than distinct raws) and short string values/raws repeat
-// too, so serving them from one shared string cuts both allocation churn and
-// retained AST strings. Same rules as WORD_CACHE: content-checked hits, only
-// lengths V8 stores flat (never slices retaining the source).
+// WHY: a direct-mapped cache for short non-word slices — WORD_CACHE's regime
+// applied to literal text. Number raws repeat heavily, a typical large input
+// holding some ten times more number literals than distinct raws, and short
+// string values and raws repeat too, so serving them from one shared string cuts
+// both allocation churn and retained AST strings. Same rules as WORD_CACHE:
+// content-checked hits, and only the lengths V8 stores flat, never a slice
+// retaining the source.
 const SLICE_CACHE_MASK = 0xfff;
 /** @type {(string | null)[]} */
 let SLICE_CACHE = NO_CACHE;
@@ -1998,10 +2087,9 @@ const wordsRegexpToSet = (re) => {
 	return new Set(body ? body.split("|") : []);
 };
 
-// One-entry identity memo in front of the string-keyed cache: acorn's
-// `wordsRegexp` interns its regexps, so identity captures the whole word set,
-// and builds construct thousands of parsers with one option set — this makes
-// the per-construction lookup three compares instead of a long key concat.
+// One-entry identity memo in front of the string-keyed cache. `wordsRegexp`
+// interns its regexps, so identity captures the whole word set, and a build
+// constructs thousands of parsers from one option set.
 /** @type {RegExp | undefined} */
 let lastKeywordsRe;
 /** @type {RegExp | undefined} */
@@ -2273,17 +2361,14 @@ class WebpackParser extends BaseParser {
 	 */
 	constructor(options, input, startPos) {
 		ensureParserCaches();
-		// fast construction for the gated hot-path shape: skip acorn's per-parse
+		// fast construction for the gated hot-path shape, skipping acorn's per-parse
 		// getOptions/wordsRegexp work. A derived constructor may return an object
-		// without calling super(); a plugin subclass's constructor body then runs
-		// on the returned object exactly as it would after its super() call.
+		// without super(), and a plugin's body then runs on it just the same.
 		const shape = getFastConstructionShape(options, input, startPos);
 		if (shape !== null) {
-			// write order below is load-bearing: acorn's constructor fields first,
-			// in dist order (a chained `a = b = v` creates b before a), then the
-			// WebpackParser fields in slow-constructor order — so fast- and
+			// write order below is load-bearing: acorn's constructor fields first, in
+			// dist order, then WebpackParser's in slow-constructor order, so fast- and
 			// slow-built instances walk one hidden-class transition chain
-			// acorn source: https://github.com/acornjs/acorn/blob/8.18.0/acorn/src/state.js
 			const self = /** @type {ParserInternals} */ (
 				/** @type {unknown} */ (Object.create(new.target.prototype))
 			);
@@ -2375,6 +2460,10 @@ class WebpackParser extends BaseParser {
 			self._arrDepth = 0;
 			self._scopePool = [];
 			self._setPool = [];
+			self._exportHeadDepth = -1;
+			self._exitedHoisted = undefined;
+			self._moduleDeclarations = undefined;
+			self._previousTopLevelStatement = undefined;
 			self._labelsStack = [];
 			self._labelsDepth = 0;
 			self._scanGapNewline = false;
@@ -2506,12 +2595,12 @@ class WebpackParser extends BaseParser {
 		this._subscriptFastPath = lazy && this._ecmaVersion >= 11;
 		const proto = WebpackParser.prototype;
 		const self = /** @type {ParserInternals} */ (/** @type {unknown} */ (this));
-		// the owned per-token loop (nextToken/finishToken/next) also serves the
+		// WHY: the owned per-token loop (nextToken/finishToken/next) also serves the
 		// public non-lazy tokenizer(): locations off, no onToken, and none of the
-		// acorn tokenizer methods it inlines or skips overridden by a plugin
-		// (`nextToken`'s punct/dot/eq shortcuts bypass `getTokenFromCode`,
-		// `finishOp`, `readToken_dot` and `readToken_eq_excl` even when the full
-		// token path below is off, so their overrides must gate this loop too)
+		// acorn tokenizer methods it inlines or skips overridden by a plugin.
+		// `nextToken`'s punct/dot/eq shortcuts bypass `getTokenFromCode`, `finishOp`,
+		// `readToken_dot` and `readToken_eq_excl` even when the full token path below
+		// is off, so their overrides must gate this loop too.
 		/** @type {boolean} */
 		this._tokenFastPath =
 			lazy ||
@@ -2586,6 +2675,24 @@ class WebpackParser extends BaseParser {
 		// pool of emptied name Sets harvested by exitScope for declareName
 		/** @type {Set<string>[]} */
 		this._setPool = [];
+		// WHY: a declaration directly under an `export` head is reported by the
+		// export statement that holds it, never by the scope, so recording is
+		// held back for exactly the one scope depth the head opened at.
+		/** @type {number} */
+		this._exportHeadDepth = -1;
+		// what the scope `exitScope` just closed had recorded, for the caller
+		// that owns that scope's node and reads it right after the call
+		/** @type {HoistedDeclarations | undefined} */
+		this._exitedHoisted = undefined;
+		// the program's import and re-export declarations, in source order, each
+		// followed by the top-level statement written before it
+		/** @type {ModuleDeclarations | undefined} */
+		this._moduleDeclarations = undefined;
+		// WHY: what precedes a module declaration decides whether removing it
+		// joins two statements through ASI, so the consumer needs it and cannot
+		// read it back off a list holding declarations alone.
+		/** @type {Node | undefined} */
+		this._previousTopLevelStatement = undefined;
 		// per-depth pool of function-body label arrays (see parseFunctionBody)
 		/** @type {{ kind?: string | null, name?: string, statementStart?: number }[][]} */
 		this._labelsStack = [];
@@ -2612,10 +2719,9 @@ class WebpackParser extends BaseParser {
 			this.parseIfStatement === proto.parseIfStatement &&
 			this.parseReturnStatement === proto.parseReturnStatement &&
 			this.parseExpressionStatement === proto.parseExpressionStatement;
-		// last arrow finished by parseArrowExpression: `expr === this._lastArrow`
-		// replaces the megamorphic `expr.type === "ArrowFunctionExpression"`
-		// probes on the expression spine (arrows are created in exactly one place
-		// and never backtracked, so identity captures the type test)
+		// last arrow finished by parseArrowExpression, so `expr === this._lastArrow`
+		// replaces the megamorphic type probes on the expression spine: arrows are
+		// created in one place and never backtracked, so identity captures the test
 		/** @type {Expression | null} */
 		this._lastArrow = null;
 		// arrows must flow through parseArrowExpression for the identity probe;
@@ -2908,7 +3014,7 @@ class WebpackParser extends BaseParser {
 	 * @returns {EXPECTED_ANY} the exported declaration
 	 */
 	parseExportDeclaration(node) {
-		return this.parseStatement(null);
+		return this._inExportHead(() => this.parseStatement(null));
 	}
 
 	/**
@@ -5158,9 +5264,8 @@ class WebpackParser extends BaseParser {
 		// acorn no-ops on it — no keyword or reserved set contains a non-string
 		if (typeof name !== "string") return;
 		// every reserved word and special name below is short lowercase ASCII, so
-		// most identifiers exit on this shape gate before any string compare
-		// (`yield`/`await`/`arguments` all pass it: lengths 5/5/9 ≤ reservedMaxLen,
-		// which keywords like `instanceof` keep at ≥ 10)
+		// most identifiers exit on this shape gate before any string compare;
+		// `yield`, `await` and `arguments` all pass it
 		const lookups = this._wordLookups;
 		const nameLen = name.length;
 		if (nameLen < 2 || nameLen > lookups.reservedMaxLen) return;
@@ -5770,14 +5875,30 @@ class WebpackParser extends BaseParser {
 		// a `program` continuation node must be appended to and returned as-is,
 		// which only acorn's copy does (base parse() reaches here via dispatch)
 		if (!this._lazy || this.options.program) {
-			return baseProto().parseTopLevel.call(this, node);
+			const program = baseProto().parseTopLevel.call(this, node);
+			/** @type {EXPECTED_ANY} */
+			(program)[HOISTED_DECLARATIONS] = this._takeHoisted(this.scopeStack[0]);
+			// acorn's own loop reports no statement order, so what precedes each
+			// module declaration is unknown and the record is not kept
+			this._moduleDeclarations = undefined;
+			return program;
 		}
 		/** @type {Record<string, boolean>} */
 		const exports = Object.create(null);
 		const scratch = this._acquireScratch();
 		let count = 0;
+		let blockMask = 0;
+		/** @type {number[] | undefined} */
+		let blockOverflow;
 		while (this.type !== tokTypes.eof) {
-			scratch[count++] = this.parseStatement(null, true, exports);
+			const statement = this.parseStatement(null, true, exports);
+			if (declaresIntoBlock(statement)) {
+				if (blockOverflow !== undefined) blockOverflow.push(count);
+				else if (count <= MAX_MASKED_INDEX) blockMask |= 1 << count;
+				else blockOverflow = overflowFrom(blockMask, count);
+			}
+			scratch[count++] = statement;
+			this._previousTopLevelStatement = statement;
 		}
 		const body = this._releaseScratch(scratch, count);
 		if (this.inModule) {
@@ -5790,18 +5911,19 @@ class WebpackParser extends BaseParser {
 		}
 		this.adaptDirectivePrologue(body);
 		this.next();
-		return /** @type {Node} */ (
-			/** @type {unknown} */ (
-				new ProgramNode(
-					node.start,
-					this.lastTokEnd,
-					body,
-					this.options.sourceType === "commonjs"
-						? "script"
-						: /** @type {string} */ (this.options.sourceType)
-				)
-			)
+		const program = new ProgramNode(
+			node.start,
+			this.lastTokEnd,
+			body,
+			this.options.sourceType === "commonjs"
+				? "script"
+				: /** @type {string} */ (this.options.sourceType)
 		);
+		program[HOISTED_DECLARATIONS] = this._takeHoisted(this.scopeStack[0]);
+		program[MODULE_DECLARATIONS] = this._takeModuleDeclarations();
+		program[BLOCK_DECLARATIONS] =
+			blockOverflow === undefined ? blockMask : blockOverflow;
+		return /** @type {Node} */ (/** @type {unknown} */ (program));
 	}
 
 	/**
@@ -6139,12 +6261,14 @@ class WebpackParser extends BaseParser {
 	 */
 	parseVarStatement(node, kind, allowMissingInitializer) {
 		if (!this._lazy || !this._varIdOwn) {
-			return baseProto().parseVarStatement.call(
+			const declaration = baseProto().parseVarStatement.call(
 				this,
 				node,
 				kind,
 				allowMissingInitializer
 			);
+			if (kind === "var") this._recordHoisted(declaration);
+			return declaration;
 		}
 		return this._parseVarStatementAt(node.start, kind, allowMissingInitializer);
 	}
@@ -6169,11 +6293,13 @@ class WebpackParser extends BaseParser {
 		);
 		const declarations = this._releaseScratch(scratch, count);
 		this.semicolon();
-		return /** @type {Node} */ (
+		const node = /** @type {Node} */ (
 			/** @type {unknown} */ (
 				new VariableDeclarationNode(start, this.lastTokEnd, declarations, kind)
 			)
 		);
+		if (kind === "var") this._recordHoisted(node);
+		return node;
 	}
 
 	/**
@@ -6326,23 +6452,31 @@ class WebpackParser extends BaseParser {
 		const start = this.start;
 		const scratch = this._acquireScratch();
 		let count = 0;
+		let blockMask = 0;
+		/** @type {number[] | undefined} */
+		let blockOverflow;
 		this.expect(tokTypes.braceL);
 		if (createNewLexicalScope) this.enterScope(0);
 		while (this.type !== tokTypes.braceR) {
-			scratch[count++] = this.parseStatement(null);
+			const statement = this.parseStatement(null);
+			if (declaresIntoBlock(statement)) {
+				if (blockOverflow !== undefined) blockOverflow.push(count);
+				else if (count <= MAX_MASKED_INDEX) blockMask |= 1 << count;
+				else blockOverflow = overflowFrom(blockMask, count);
+			}
+			scratch[count++] = statement;
 		}
 		if (exitStrict) this.strict = false;
 		this.next();
 		if (createNewLexicalScope) this.exitScope();
-		return /** @type {Node} */ (
-			/** @type {unknown} */ (
-				new BlockStatementNode(
-					start,
-					this.lastTokEnd,
-					this._releaseScratch(scratch, count)
-				)
-			)
+		const block = new BlockStatementNode(
+			start,
+			this.lastTokEnd,
+			this._releaseScratch(scratch, count)
 		);
+		block[BLOCK_DECLARATIONS] =
+			blockOverflow === undefined ? blockMask : blockOverflow;
+		return /** @type {Node} */ (/** @type {unknown} */ (block));
 	}
 
 	/**
@@ -6522,6 +6656,7 @@ class WebpackParser extends BaseParser {
 					)
 				)
 			);
+			if (kind === "var") this._recordHoisted(init);
 			return this._parseForAfterInitAt(start, init, awaitAt);
 		}
 		const startsWithLet = this.isContextual("let");
@@ -6727,10 +6862,19 @@ class WebpackParser extends BaseParser {
 		this.enterScope(SCOPE_SWITCH);
 		/** @type {SwitchCaseNode | undefined} */
 		let cur;
+		let caseMask = 0;
+		/** @type {number[] | undefined} */
+		let caseOverflow;
 		for (let sawDefault = false; this.type !== tokTypes.braceR;) {
 			if (this.type === tokTypes._case || this.type === tokTypes._default) {
 				const isCase = this.type === tokTypes._case;
-				if (cur) this.finishNode(/** @type {Node} */ (cur), "SwitchCase");
+				if (cur) {
+					cur[BLOCK_DECLARATIONS] =
+						caseOverflow === undefined ? caseMask : caseOverflow;
+					this.finishNode(/** @type {Node} */ (cur), "SwitchCase");
+				}
+				caseMask = 0;
+				caseOverflow = undefined;
 				cur = new SwitchCaseNode(this.start);
 				cases.push(/** @type {Node} */ (cur));
 				cur.consequent = [];
@@ -6750,13 +6894,25 @@ class WebpackParser extends BaseParser {
 				this.expect(tokTypes.colon);
 			} else {
 				if (!cur) this.unexpected();
-				/** @type {Node[]} */ (
-					/** @type {SwitchCaseNode} */ (cur).consequent
-				).push(this.parseStatement(null));
+				const consequent =
+					/** @type {Node[]} */
+					(/** @type {SwitchCaseNode} */ (cur).consequent);
+				const statement = this.parseStatement(null);
+				if (declaresIntoBlock(statement)) {
+					const index = consequent.length;
+					if (caseOverflow !== undefined) caseOverflow.push(index);
+					else if (index <= MAX_MASKED_INDEX) caseMask |= 1 << index;
+					else caseOverflow = overflowFrom(caseMask, index);
+				}
+				consequent.push(statement);
 			}
 		}
 		this.exitScope();
-		if (cur) this.finishNode(/** @type {Node} */ (cur), "SwitchCase");
+		if (cur) {
+			cur[BLOCK_DECLARATIONS] =
+				caseOverflow === undefined ? caseMask : caseOverflow;
+			this.finishNode(/** @type {Node} */ (cur), "SwitchCase");
+		}
 		this.next(); // closing brace
 		this.labels.pop();
 		return /** @type {Node} */ (
@@ -7094,16 +7250,12 @@ class WebpackParser extends BaseParser {
 		this.yieldPos = oldYieldPos;
 		this.awaitPos = oldAwaitPos;
 		this.awaitIdentPos = oldAwaitIdentPos;
-		return /** @type {Expression} */ (
-			/** @type {unknown} */ (
-				this.finishNode(
-					node,
-					statement & FUNC_STATEMENT
-						? "FunctionDeclaration"
-						: "FunctionExpression"
-				)
-			)
+		const finished = this.finishNode(
+			node,
+			statement & FUNC_STATEMENT ? "FunctionDeclaration" : "FunctionExpression"
 		);
+		if (statement & FUNC_STATEMENT) this._recordHoisted(finished);
+		return /** @type {Expression} */ (/** @type {unknown} */ (finished));
 	}
 
 	/**
@@ -7115,13 +7267,23 @@ class WebpackParser extends BaseParser {
 	 */
 	parseFunctionBody(node, isArrowFunction, isMethod, forInit) {
 		if (!this._funcFastPath) {
-			return baseProto().parseFunctionBody.call(
+			baseProto().parseFunctionBody.call(
 				this,
 				node,
 				isArrowFunction,
 				isMethod,
 				forInit
 			);
+			const body = /** @type {Node & { body: Node }} */ (node).body;
+			if (body.type === "BlockStatement") {
+				/** @type {EXPECTED_ANY} */
+				(body)[HOISTED_DECLARATIONS] = !this._recordsHoisted()
+					? undefined
+					: this._exitedHoisted === undefined
+						? NO_HOISTED_DECLARATIONS
+						: this._exitedHoisted;
+			}
+			return;
 		}
 		const target =
 			/** @type {Node & { id: Identifier | null, params: Node[], body: Node, expression: boolean }} */ (
@@ -7181,6 +7343,11 @@ class WebpackParser extends BaseParser {
 			);
 			this._labelsDepth--;
 			this.labels = oldLabels;
+			/** @type {EXPECTED_ANY} */
+			(target.body)[HOISTED_DECLARATIONS] = this._takeHoisted(
+				this.currentScope()
+			);
+			this._exitedHoisted = undefined;
 		}
 		this.exitScope();
 	}
@@ -8726,7 +8893,9 @@ class WebpackParser extends BaseParser {
 	 */
 	parseClass(node, isStatement) {
 		if (!this._classFastPath) {
-			return baseProto().parseClass.call(this, node, isStatement);
+			const parsed = baseProto().parseClass.call(this, node, isStatement);
+			if (isStatement) this._recordHoisted(parsed);
+			return parsed;
 		}
 		const classNode =
 			/** @type {Node & { id: Identifier | null, superClass: Expression | null, body: Node | null }} */ (
@@ -8786,10 +8955,12 @@ class WebpackParser extends BaseParser {
 			)
 		);
 		this.exitClassBody();
-		return this.finishNode(
+		const finished = this.finishNode(
 			/** @type {Node} */ (/** @type {unknown} */ (classNode)),
 			isStatement ? "ClassDeclaration" : "ClassExpression"
 		);
+		if (isStatement) this._recordHoisted(finished);
+		return finished;
 	}
 
 	/**
@@ -9031,11 +9202,23 @@ class WebpackParser extends BaseParser {
 		target.body = [];
 		const oldLabels = this.labels;
 		this.labels = [];
+		let blockMask = 0;
+		/** @type {number[] | undefined} */
+		let blockOverflow;
 		this.enterScope(SCOPE_CLASS_STATIC_BLOCK | SCOPE_SUPER);
 		while (this.type !== tokTypes.braceR) {
 			const statement = this.parseStatement(null);
+			if (declaresIntoBlock(statement)) {
+				const index = target.body.length;
+				if (blockOverflow !== undefined) blockOverflow.push(index);
+				else if (index <= MAX_MASKED_INDEX) blockMask |= 1 << index;
+				else blockOverflow = overflowFrom(blockMask, index);
+			}
 			target.body.push(statement);
 		}
+		/** @type {EXPECTED_ANY} */
+		(target)[BLOCK_DECLARATIONS] =
+			blockOverflow === undefined ? blockMask : blockOverflow;
 		this.next();
 		this.exitScope();
 		this.labels = oldLabels;
@@ -9537,6 +9720,10 @@ class WebpackParser extends BaseParser {
 			scope.functions = undefined;
 		}
 		scope.firstLexical = undefined;
+		this._exitedHoisted = scope.hoisted;
+		scope.hoisted = undefined;
+		// a recorded list is the consumer's now, and an empty one is still a
+		// record — what must never reach it is the list of some earlier scope
 		this._scopePool.push(scope);
 	}
 
@@ -9548,6 +9735,115 @@ class WebpackParser extends BaseParser {
 		return cached === undefined ? new Set() : cached;
 	}
 
+	/**
+	 * Record a declaration statement on the var scope it hoists to, in source
+	 * order. A declaration under an `export` head belongs to that statement.
+	 * @param {EXPECTED_ANY} node the declaration statement
+	 * @returns {void}
+	 */
+	_recordHoisted(node) {
+		if (!this._recordsHoisted()) return;
+		if (this.scopeStack.length === this._exportHeadDepth) return;
+		const scope = this.currentVarScope();
+		if (scope.hoisted === undefined) scope.hoisted = [node];
+		else scope.hoisted.push(node);
+	}
+
+	/**
+	 * Hand the scope's recorded declarations to the node that owns it, leaving
+	 * the slot empty for the pool. Call it before the matching `exitScope`.
+	 * @param {Scope} scope the scope being closed
+	 * @returns {HoistedDeclarations | undefined} the declarations, in source order
+	 */
+	_takeHoisted(scope) {
+		if (!this._recordsHoisted()) return undefined;
+		const hoisted = scope.hoisted;
+		if (hoisted === undefined) return NO_HOISTED_DECLARATIONS;
+		scope.hoisted = undefined;
+		return hoisted;
+	}
+
+	/**
+	 * Whether the declarations of each scope are recorded at all: only when every
+	 * production that reaches a recording site is this class's own, since an
+	 * override of any of them leaves the record silently short.
+	 * @returns {boolean} whether the record is kept
+	 */
+	_recordsHoisted() {
+		return (
+			this._lazy &&
+			this._stmtFastPath &&
+			this._funcStmtOwn &&
+			this._stmt2FastPath &&
+			this.parseClass === WebpackParser.prototype.parseClass
+		);
+	}
+
+	/**
+	 * Record an import or re-export the program states directly. One nested
+	 * deeper belongs to no program, so only the top-level list is kept.
+	 * @param {EXPECTED_ANY} node the finished declaration
+	 * @returns {void}
+	 */
+	_recordModuleDeclaration(node) {
+		if (this.scopeStack.length !== 1) return;
+		const type = node.type;
+		if (
+			type !== "ImportDeclaration" &&
+			type !== "ExportNamedDeclaration" &&
+			type !== "ExportAllDeclaration"
+		) {
+			return;
+		}
+		const previous = this._previousTopLevelStatement;
+		if (this._moduleDeclarations === undefined) {
+			this._moduleDeclarations = [node, previous];
+		} else {
+			this._moduleDeclarations.push(node, previous);
+		}
+	}
+
+	/**
+	 * Hand the program its module declarations, leaving the slot empty.
+	 * @returns {ModuleDeclarations | undefined} them, in source order
+	 */
+	_takeModuleDeclarations() {
+		if (!this._recordsModuleDeclarations()) return undefined;
+		const declarations = this._moduleDeclarations;
+		if (declarations === undefined) return NO_MODULE_DECLARATIONS;
+		this._moduleDeclarations = undefined;
+		return declarations;
+	}
+
+	/**
+	 * Whether imports and re-exports are recorded at all: only when this class
+	 * reads them, since an override of either is what would go unrecorded.
+	 * @returns {boolean} whether the record is kept
+	 */
+	_recordsModuleDeclarations() {
+		const proto = WebpackParser.prototype;
+		return (
+			this._lazy &&
+			this.parseImport === proto.parseImport &&
+			this.parseExport === proto.parseExport
+		);
+	}
+
+	/**
+	 * Run `parse` with declaration recording held back for the scope depth it
+	 * opens at, which is how an `export` head keeps its own declaration.
+	 * @template T
+	 * @param {() => T} parse what reads the declaration
+	 * @returns {T} whatever it read
+	 */
+	_inExportHead(parse) {
+		const previous = this._exportHeadDepth;
+		this._exportHeadDepth = this.scopeStack.length;
+		const declaration = parse();
+		this._exportHeadDepth = previous;
+		return declaration;
+	}
+
 	/**
 	 * Record a name in the scope its binding belongs to, and report a name that
 	 * was already declared there.
@@ -9744,6 +10040,16 @@ class WebpackParser extends BaseParser {
 	 * @returns {EXPECTED_ANY} the finished import
 	 */
 	parseImport(node) {
+		const declaration = this._parseImport(node);
+		this._recordModuleDeclaration(declaration);
+		return declaration;
+	}
+
+	/**
+	 * @param {EXPECTED_ANY} node the import node
+	 * @returns {EXPECTED_ANY} the finished import
+	 */
+	_parseImport(node) {
 		this._moduleSyntaxSeen = true;
 		this._importPhase = null;
 		if (!this._moduleDeclFastPath) {
@@ -9900,6 +10206,17 @@ class WebpackParser extends BaseParser {
 	 * @returns {EXPECTED_ANY} the finished export
 	 */
 	parseExport(node, exports) {
+		const declaration = this._parseExport(node, exports);
+		this._recordModuleDeclaration(declaration);
+		return declaration;
+	}
+
+	/**
+	 * @param {EXPECTED_ANY} node the export node
+	 * @param {EXPECTED_ANY} exports where module exports are tracked
+	 * @returns {EXPECTED_ANY} the finished export
+	 */
+	_parseExport(node, exports) {
 		this._moduleSyntaxSeen = true;
 		if (!this._moduleDeclFastPath) {
 			return baseProto().parseExport.call(this, node, exports);
@@ -10026,6 +10343,11 @@ class WebpackParser extends BaseParser {
 
 	/** @returns {EXPECTED_ANY} what `export default` exports */
 	parseExportDefaultDeclaration() {
+		return this._inExportHead(() => this._parseExportDefaultDeclaration());
+	}
+
+	/** @returns {EXPECTED_ANY} what `export default` exports */
+	_parseExportDefaultDeclaration() {
 		if (!this._moduleDeclFastPath) {
 			return baseProto().parseExportDefaultDeclaration.call(this);
 		}
@@ -10942,11 +11264,17 @@ const parse = (input, options) =>
 		)
 	);
 
+module.exports.BLOCK_DECLARATIONS = BLOCK_DECLARATIONS;
+module.exports.MAX_MASKED_INDEX = MAX_MASKED_INDEX;
+module.exports.HOISTED_DECLARATIONS = HOISTED_DECLARATIONS;
+module.exports.MODULE_DECLARATIONS = MODULE_DECLARATIONS;
 module.exports.LEGACY_ASSERT_ATTRIBUTES = LEGACY_ASSERT_ATTRIBUTES;
 module.exports.ParserPosition = ParserPosition;
 module.exports.WebpackParser = WebpackParser;
 module.exports.buildLineStarts = buildLineStarts;
 module.exports.collectCjsRequireSpecifiers = collectCjsRequireSpecifiers;
+module.exports.declaresIntoBlock = declaresIntoBlock;
+module.exports.overflowFrom = overflowFrom;
 module.exports.hasOctalEscape = hasOctalEscape;
 module.exports.isIdentifierChar = isIdentifierChar;
 module.exports.parse = parse;