webpack 5.110.2 → 5.111.0

package/lib/rules/RuleSetCompiler.js

@@ -7,6 +7,7 @@
 
 const { SyncHook } = require("tapable");
 const { createPathGlobMatcher } = require("../util/globUtils");
+const { fileUrlToPath } = require("../util/identifier");
 
 /** @import { ResolveRequest } from "enhanced-resolve" */
 /**
@@ -352,9 +353,10 @@ class RuleSetCompiler {
 			);
 		}
 		if (typeof condition === "string") {
+			const prefix = fileUrlToPath(condition);
 			return {
-				matchWhenEmpty: condition.length === 0,
-				fn: (str) => typeof str === "string" && str.startsWith(condition)
+				matchWhenEmpty: prefix.length === 0,
+				fn: (str) => typeof str === "string" && str.startsWith(prefix)
 			};
 		}
 		if (typeof condition === "function") {
@@ -640,6 +642,200 @@ const matchRuleSetCondition = (condition, resource) => {
 	}
 };
 
+// Cap on the spellings one pattern is expanded into, so a pattern built from
+// many alternations stays cheap to probe.
+const MAX_EXPANDED_SPELLINGS = 64;
+
+// A rule naming an extension is short; a pattern generated from a list of paths
+// runs to kilobytes and costs more to expand than the answer is worth.
+const MAX_EXPANDED_PATTERN_LENGTH = 256;
+
+/**
+ * Index of the `]` closing the character class opened at `start`, or the end of
+ * the source when it is unterminated.
+ * @param {string} source regexp source
+ * @param {number} start index of the opening `[`
+ * @returns {number} index of the closing `]`
+ */
+const findCharacterClassEnd = (source, start) => {
+	for (let i = start + 1; i < source.length; i++) {
+		if (source[i] === "\\") i++;
+		else if (source[i] === "]") return i;
+	}
+	return source.length;
+};
+
+/**
+ * Index of the `)` closing the group opened at `start`, skipping nested groups
+ * and character classes, or the end of the source when it is unterminated.
+ * @param {string} source regexp source
+ * @param {number} start index of the opening `(`
+ * @returns {number} index of the closing `)`
+ */
+const findGroupEnd = (source, start) => {
+	let depth = 0;
+	for (let i = start; i < source.length; i++) {
+		const char = source[i];
+		if (char === "\\") i++;
+		else if (char === "[") i = findCharacterClassEnd(source, i);
+		else if (char === "(") depth++;
+		else if (char === ")" && --depth === 0) return i;
+	}
+	return source.length;
+};
+
+/**
+ * Splits a group body on its top-level `|`, skipping nested groups and
+ * character classes.
+ * @param {string} body group body without the enclosing parentheses
+ * @returns {string[]} the alternatives
+ */
+const splitAlternatives = (body) => {
+	const alternatives = [];
+	let depth = 0;
+	let start = 0;
+	for (let i = 0; i < body.length; i++) {
+		const char = body[i];
+		if (char === "\\") {
+			i++;
+		} else if (char === "[") {
+			i = findCharacterClassEnd(body, i);
+		} else if (char === "(") {
+			depth++;
+		} else if (char === ")") {
+			depth--;
+		} else if (char === "|" && depth === 0) {
+			alternatives.push(body.slice(start, i));
+			start = i + 1;
+		}
+	}
+	alternatives.push(body.slice(start));
+	return alternatives;
+};
+
+/**
+ * The part of a group body that the match spells — past a `?:` or `?<name>`
+ * prefix, and nothing at all for a lookaround, which spells nothing.
+ * @param {string} body group body without the enclosing parentheses
+ * @returns {string | undefined} the spelled part, or `undefined` for a lookaround
+ */
+const groupContent = (body) => {
+	if (!body.startsWith("?")) return body;
+	if (body.startsWith("?:")) return body.slice(2);
+	const named = /^\?<[^=!][^>]*>/.exec(body);
+	return named ? body.slice(named[0].length) : undefined;
+};
+
+/**
+ * Rewrites the first group, word-character class or optional atom
+ * in the source into the spellings it can match, leaving the rest as written.
+ * @param {string} source regexp source
+ * @returns {string[] | undefined} the rewritten sources, or `undefined` when the source holds no such construct
+ */
+const expandFirstConstruct = (source) => {
+	for (let i = 0; i < source.length; i++) {
+		const char = source[i];
+		let end = i + 1;
+		/** @type {string[] | undefined} */
+		let spellings;
+		if (char === "\\") {
+			end = i + 2;
+		} else if (char === "[") {
+			const close = findCharacterClassEnd(source, i);
+			end = close + 1;
+			const body = source.slice(i + 1, close);
+			// only a plain list of word characters spells out safely (no range,
+			// no negation, no escape)
+			if (/^\w+$/.test(body)) spellings = [...body];
+		} else if (char === "(") {
+			const close = findGroupEnd(source, i);
+			end = close + 1;
+			const content = groupContent(source.slice(i + 1, close));
+			if (content !== undefined) spellings = splitAlternatives(content);
+		}
+		// `?` makes the atom optional, so its absence is a spelling as well
+		if (source[end] === "?") {
+			spellings = [...(spellings || [source.slice(i, end)]), ""];
+			end += 1;
+		}
+		if (spellings) {
+			return spellings.map(
+				(spelling) => source.slice(0, i) + spelling + source.slice(end)
+			);
+		}
+		i = end - 1;
+	}
+};
+
+/**
+ * Rewrites the first brace alternative in a glob pattern (e.g. `*.{css,scss}`)
+ * into the spellings it can match.
+ * @param {string} pattern glob pattern
+ * @returns {string[] | undefined} the rewritten patterns, or `undefined` when the pattern holds no brace
+ */
+const expandFirstBrace = (pattern) => {
+	const open = pattern.indexOf("{");
+	const close = open === -1 ? -1 : pattern.indexOf("}", open);
+	if (close === -1) return;
+	return pattern
+		.slice(open + 1, close)
+		.split(",")
+		.map(
+			(alternative) =>
+				pattern.slice(0, open) + alternative + pattern.slice(close + 1)
+		);
+};
+
+/**
+ * Whether `probe` occurs in `pattern` as a subsequence. Expanding a pattern only
+ * ever drops characters, so a probe failing this is spelled by none of its
+ * spellings and the expansion is not worth starting.
+ * @param {string} pattern pattern to search
+ * @param {string} probe probe to find
+ * @returns {boolean} whether the probe is a subsequence of the pattern
+ */
+const containsSubsequence = (pattern, probe) => {
+	let found = 0;
+	for (let i = 0; i < pattern.length && found < probe.length; i++) {
+		if (pattern[i] === probe[found]) found++;
+	}
+	return found === probe.length;
+};
+
+/**
+ * Whether any spelling of the pattern contains the probe, rewriting one
+ * construct at a time until none is left or `MAX_EXPANDED_SPELLINGS` is reached.
+ * @param {string} pattern pattern to expand
+ * @param {string} probe probe the spellings are searched for
+ * @param {(pattern: string) => string[] | undefined} expandFirst rewrites the first expandable construct
+ * @returns {boolean} whether a spelling contains the probe
+ */
+const someSpellingContains = (pattern, probe, expandFirst) => {
+	if (pattern.includes(probe)) return true;
+	if (pattern.length > MAX_EXPANDED_PATTERN_LENGTH) return false;
+	if (!containsSubsequence(pattern, probe)) return false;
+	let spellings = [pattern];
+	for (;;) {
+		/** @type {string[]} */
+		const expanded = [];
+		for (const spelling of spellings) {
+			const rewritten = expandFirst(spelling);
+			// every spelling was searched as it was produced, so one with nothing
+			// left to rewrite is settled
+			if (!rewritten) continue;
+			for (const alternative of rewritten) {
+				if (alternative.includes(probe)) return true;
+				// an alternative that dropped the probe's characters expands no
+				// further into it
+				if (containsSubsequence(alternative, probe)) expanded.push(alternative);
+			}
+			if (expanded.length > MAX_EXPANDED_SPELLINGS) return false;
+		}
+		if (expanded.length === 0) return false;
+		spellings = expanded;
+	}
+};
+
 /**
  * @param {EXPECTED_ANY} glob glob pattern(s)
  * @param {string} extension extension including the dot (e.g. `".css"`)
@@ -648,7 +844,10 @@ const matchRuleSetCondition = (condition, resource) => {
 const globReferencesExtension = (glob, extension) => {
 	// a `!` pattern subtracts the extension instead of targeting it
 	if (typeof glob === "string") {
-		return !glob.startsWith("!") && glob.includes(extension);
+		return (
+			!glob.startsWith("!") &&
+			someSpellingContains(glob, extension, expandFirstBrace)
+		);
 	}
 	return (
 		Array.isArray(glob) &&
@@ -660,12 +859,20 @@ const globReferencesExtension = (glob, extension) => {
  * Whether any regexp or glob in the condition references the extension probe
  * (e.g. `\.css`), i.e. the rule clearly targets that extension even if the
  * generic sample path doesn't match its (possibly filename-scoped) pattern.
+ * The extension may be spelled by an alternation (`\.(css|scss)$`) or a
+ * character class (`\.[jt]sx?$`), so those are expanded before probing.
  * @param {EXPECTED_ANY} condition condition
  * @param {string} extProbe escaped extension probe (e.g. `"\\.css"`)
  * @returns {boolean} whether a regexp in the condition targets the extension
  */
 const conditionReferencesExtension = (condition, extProbe) => {
-	if (condition instanceof RegExp) return condition.source.includes(extProbe);
+	if (condition instanceof RegExp) {
+		// an `/i` rule spells the extension in any case; the probe is lower case
+		const source = condition.ignoreCase
+			? condition.source.toLowerCase()
+			: condition.source;
+		return someSpellingContains(source, extProbe, expandFirstConstruct);
+	}
 	if (Array.isArray(condition)) {
 		return condition.some((c) => conditionReferencesExtension(c, extProbe));
 	}

package/lib/runtime/AsyncModuleRuntimeModule.js

@@ -13,11 +13,14 @@ const HelperRuntimeModule = require("./HelperRuntimeModule");
 class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 	/**
 	 * @param {boolean=} deferInterop if defer import is used.
+	 * @param {boolean=} strictModuleErrorHandling if a recorded evaluation error is kept.
 	 */
-	constructor(deferInterop = false) {
+	constructor(deferInterop = false, strictModuleErrorHandling = false) {
 		super("async module");
 		/** @type {boolean} */
 		this._deferInterop = deferInterop;
+		/** @type {boolean} */
+		this._strictModuleErrorHandling = strictModuleErrorHandling;
 	}
 
 	/**
@@ -29,6 +32,11 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 		const { runtimeTemplate } = compilation;
 		const fn = RuntimeGlobals.asyncModule;
 		const defer = this._deferInterop;
+		const strictErrors = this._strictModuleErrorHandling;
+		const rejectCall = "reject(promise[webpackError] = err)";
+		const rejectExpression = strictErrors
+			? `(markCycle(err), ${rejectCall})`
+			: rejectCall;
 		const cst = runtimeTemplate.renderConst();
 		const lt = runtimeTemplate.renderLet();
 		const supportsSymbol = runtimeTemplate.supportsSymbol();
@@ -46,6 +54,7 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 				defer ? `${RuntimeGlobals.asyncModuleExportSymbol}= ` : ""
 			}${renderSymbol("webpack exports", RuntimeGlobals.exports)};`,
 			`${cst} webpackError = ${renderSymbol("webpack error", "__webpack_error__")};`,
+			...(strictErrors ? [`${cst} cycleGroups = {};`] : []),
 			defer
 				? Template.asString([
 						`${cst} webpackDone = ${RuntimeGlobals.asyncModuleDoneSymbol} = ${renderSymbol("webpack done", "__webpack_done__")};`,
@@ -57,7 +66,11 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 									`${cst} hasUnresolvedAsyncSubgraph = asyncDeps.some((id) => {`,
 									Template.indent([
 										`${cst} cache = __webpack_module_cache__[id];`,
-										"return !cache || cache[webpackDone] === false;"
+										"if (!cache) return true;",
+										// A cached entry no longer means finished, and a rejected
+										// one is done but its error must still reach the importer.
+										`${cst} deps = cache.exports;`,
+										"return deps[webpackDone] !== true || deps[webpackError] !== undefined;"
 									]),
 									"});",
 									"if (hasUnresolvedAsyncSubgraph) {",
@@ -144,73 +157,98 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 				])})`,
 				"deps"
 			)};`,
-			`${fn} = ${runtimeTemplate.basicFunction("module, body, hasAwait", [
-				`${lt} queue;`,
-				"hasAwait && ((queue = []).d = -1);",
-				`${cst} depQueues = new Set();`,
-				`${cst} exports = module.exports;`,
-				`${lt} currentDeps;`,
-				`${lt} outerResolve;`,
-				`${lt} reject;`,
-				`${cst} promise = new Promise(${runtimeTemplate.basicFunction(
-					"resolve, rej",
-					["reject = rej;", "outerResolve = resolve;"]
-				)});`,
-				"promise[webpackExports] = exports;",
-				`promise[webpackQueues] = ${runtimeTemplate.expressionFunction(
-					`queue && fn(queue), depQueues.forEach(fn), promise["catch"](${runtimeTemplate.emptyFunction()})`,
-					"fn"
-				)};`,
-				"module.exports = promise;",
-				`${cst} handle = ${runtimeTemplate.basicFunction("deps", [
-					"currentDeps = wrapDeps(deps);",
-					`${lt} fn;`,
-					`${cst} getResult = ${runtimeTemplate.returningFunction(
-						`currentDeps.map(${runtimeTemplate.basicFunction("d", [
-							defer ? "if(d[webpackDefer]) return d;" : "",
-							"if(d[webpackError]) throw d[webpackError];",
-							"return d[webpackExports];"
-						])})`
-					)}`,
+			`${fn} = ${runtimeTemplate.basicFunction(
+				strictErrors
+					? "module, body, hasAwait, cycleGroup"
+					: "module, body, hasAwait",
+				[
+					`${lt} queue;`,
+					"hasAwait && ((queue = []).d = -1);",
+					`${cst} depQueues = new Set();`,
+					`${cst} exports = module.exports;`,
+					`${lt} currentDeps;`,
+					`${lt} outerResolve;`,
+					`${lt} reject;`,
 					`${cst} promise = new Promise(${runtimeTemplate.basicFunction(
-						"resolve",
-						[
-							`fn = ${runtimeTemplate.expressionFunction(
-								"resolve(getResult)",
-								""
-							)};`,
-							"fn.r = 0;",
-							`${cst} fnQueue = ${runtimeTemplate.expressionFunction(
-								"q !== queue && !depQueues.has(q) && (depQueues.add(q), q && !q.d && (fn.r++, q.push(fn)))",
-								"q"
-							)};`,
-							`currentDeps.forEach(${runtimeTemplate.expressionFunction(
-								`${
-									defer ? "dep[webpackDefer]||" : ""
-								}dep[webpackQueues](fnQueue)`,
-								"dep"
-							)});`
-						]
+						"resolve, rej",
+						["reject = rej;", "outerResolve = resolve;"]
 					)});`,
-					"return fn.r ? promise : getResult();"
-				])}`,
-				`${cst} done = ${runtimeTemplate.expressionFunction(
-					`(err ? reject(promise[webpackError] = err) : outerResolve(exports)), resolveQueue(queue)${
-						defer
-							? ", promise[webpackDone] = true, module.evaluatingAsync = false"
-							: ""
-					}`,
-					"err"
-				)}`,
-				// Track the async body's whole lifetime (evaluating +
-				// evaluating-async states) with a dedicated flag — the sync require
-				// wrapper clears `module.evaluating` as soon as `.a` returns, so a
-				// deferred namespace reaching this module through a cycle relies on
-				// `evaluatingAsync` to keep throwing until it is fully evaluated.
-				defer ? "module.evaluatingAsync = true;" : "",
-				"body(handle, done);",
-				`${runtimeTemplate.optionalChaining("queue", "d < 0")} && (queue.d = 0);`
-			])};`
+					"promise[webpackExports] = exports;",
+					`promise[webpackQueues] = ${runtimeTemplate.expressionFunction(
+						`queue && fn(queue), depQueues.forEach(fn), promise["catch"](${runtimeTemplate.emptyFunction()})`,
+						"fn"
+					)};`,
+					"module.exports = promise;",
+					`${cst} handle = ${runtimeTemplate.basicFunction("deps", [
+						"currentDeps = wrapDeps(deps);",
+						`${lt} fn;`,
+						`${cst} getResult = ${runtimeTemplate.returningFunction(
+							`currentDeps.map(${runtimeTemplate.basicFunction("d", [
+								defer ? "if(d[webpackDefer]) return d;" : "",
+								"if(d[webpackError]) throw d[webpackError];",
+								"return d[webpackExports];"
+							])})`
+						)}`,
+						`${cst} promise = new Promise(${runtimeTemplate.basicFunction(
+							"resolve",
+							[
+								`fn = ${runtimeTemplate.expressionFunction(
+									"resolve(getResult)",
+									""
+								)};`,
+								"fn.r = 0;",
+								`${cst} fnQueue = ${runtimeTemplate.expressionFunction(
+									"q !== queue && !depQueues.has(q) && (depQueues.add(q), q && !q.d && (fn.r++, q.push(fn)))",
+									"q"
+								)};`,
+								`currentDeps.forEach(${runtimeTemplate.expressionFunction(
+									`${
+										defer ? "dep[webpackDefer]||" : ""
+									}dep[webpackQueues](fnQueue)`,
+									"dep"
+								)});`
+							]
+						)});`,
+						"return fn.r ? promise : getResult();"
+					])}`,
+					// One `[[EvaluationError]]` is recorded for a whole strongly-connected
+					// component, so a peer that already fulfilled must report it too.
+					...(strictErrors
+						? [
+								`${cst} group = cycleGroup === undefined ? undefined : (cycleGroups[cycleGroup] = cycleGroups[cycleGroup] || []);`,
+								// Ids, not module objects: hot replacement swaps a member for a
+								// new object under the same id, and the error belongs to that one.
+								"group && group.indexOf(module.id) < 0 && group.push(module.id);",
+								`${cst} markCycle = ${runtimeTemplate.expressionFunction(
+									`group && group.forEach(${runtimeTemplate.basicFunction(
+										"id",
+										[
+											`${cst} peer = __webpack_module_cache__[id];`,
+											"if (peer && peer.error === undefined) peer.error = err;"
+										]
+									)})`,
+									"err"
+								)};`
+							]
+						: []),
+					`${cst} done = ${runtimeTemplate.expressionFunction(
+						`(err ? ${rejectExpression} : outerResolve(exports)), resolveQueue(queue)${
+							defer
+								? ", promise[webpackDone] = true, module.evaluatingAsync = false"
+								: ""
+						}`,
+						"err"
+					)}`,
+					// Track the async body's whole lifetime (evaluating +
+					// evaluating-async states) with a dedicated flag — the sync require
+					// wrapper clears `module.evaluating` as soon as `.a` returns, so a
+					// deferred namespace reaching this module through a cycle relies on
+					// `evaluatingAsync` to keep throwing until it is fully evaluated.
+					defer ? "module.evaluatingAsync = true;" : "",
+					"body(handle, done);",
+					`${runtimeTemplate.optionalChaining("queue", "d < 0")} && (queue.d = 0);`
+				]
+			)};`
 		]);
 	}
 }

package/lib/runtime/AutoPublicPathRuntimeModule.js

@@ -17,6 +17,15 @@ class AutoPublicPathRuntimeModule extends RuntimeModule {
 		super("publicPath", RuntimeModule.STAGE_BASIC);
 	}
 
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		return RuntimeModule.NO_CHUNK_HANDLERS;
+	}
+
 	/**
 	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code

package/lib/runtime/BaseUriRuntimeModule.js

@@ -32,6 +32,15 @@ class BaseUriRuntimeModule extends RuntimeModule {
 		return false;
 	}
 
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		return RuntimeModule.NO_CHUNK_HANDLERS;
+	}
+
 	/**
 	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code

package/lib/runtime/ChunkNameRuntimeModule.js

@@ -27,6 +27,15 @@ class ChunkNameRuntimeModule extends RuntimeModule {
 		this.chunkName = chunkName;
 	}
 
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		return RuntimeModule.NO_CHUNK_HANDLERS;
+	}
+
 	/**
 	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code

package/lib/runtime/EnsureChunkRuntimeModule.js

@@ -7,6 +7,8 @@
 const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
+const { getOnlyHandlerKey } = require("../util/handlerKeys");
+const { propertyAccess } = require("../util/property");
 
 /** @import Compilation from "../Compilation" */
 /** @import { ReadOnlyRuntimeRequirements } from "../Module" */
@@ -31,6 +33,17 @@ class EnsureChunkRuntimeModule extends RuntimeModule {
 		this.runtimeRequirements = runtimeRequirements;
 	}
 
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		// Reads a map rather than installing onto one, so reading its code back would
+		// render it in a cycle.
+		return RuntimeModule.NO_CHUNK_HANDLERS;
+	}
+
 	/**
 	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code
@@ -38,8 +51,8 @@ class EnsureChunkRuntimeModule extends RuntimeModule {
 	generate() {
 		const compilation = /** @type {Compilation} */ (this.compilation);
 		const { runtimeTemplate } = compilation;
-		// An analyzable `import()` dispatches the handlers itself, so a build can need the
-		// map without the function around it.
+		// HMR force-loads through the handler map by bare chunk id, so a build can need
+		// the map without the function around it.
 		const withEnsureChunk = this.runtimeRequirements.has(
 			RuntimeGlobals.ensureChunk
 		);
@@ -50,24 +63,30 @@ class EnsureChunkRuntimeModule extends RuntimeModule {
 			);
 			const handlers = RuntimeGlobals.ensureChunkHandlers;
 			if (!withEnsureChunk) return `${handlers} = {};`;
+			const args = `chunkId${withFetchPriority ? ", fetchPriority" : ""}`;
+			const forwarded = `chunkId, promises${
+				withFetchPriority ? ", fetchPriority" : ""
+			}`;
+			const only = getOnlyHandlerKey(this, handlers);
+			// One handler needs no walk over the others, and most chunks carry one.
+			const body =
+				only === null
+					? `return Promise.all(Object.keys(${handlers}).reduce(${runtimeTemplate.basicFunction(
+							"promises, key",
+							[`${handlers}[key](${forwarded});`, "return promises;"]
+						)}, []));`
+					: Template.asString([
+							`${runtimeTemplate.renderConst()} promises = [];`,
+							`${handlers}${propertyAccess([only])}(${forwarded});`,
+							"return Promise.all(promises);"
+						]);
 			return Template.asString([
 				`${handlers} = {};`,
 				"// This file contains only the entry chunk.",
 				"// The chunk loading function for additional chunks",
-				`${RuntimeGlobals.ensureChunk} = ${runtimeTemplate.basicFunction(
-					`chunkId${withFetchPriority ? ", fetchPriority" : ""}`,
-					[
-						`return Promise.all(Object.keys(${handlers}).reduce(${runtimeTemplate.basicFunction(
-							"promises, key",
-							[
-								`${handlers}[key](chunkId, promises${
-									withFetchPriority ? ", fetchPriority" : ""
-								});`,
-								"return promises;"
-							]
-						)}, []));`
-					]
-				)};`
+				`${RuntimeGlobals.ensureChunk} = ${runtimeTemplate.basicFunction(args, [
+					body
+				])};`
 			]);
 		}
 		// There ensureChunk is used somewhere in the tree, so we need an empty requireEnsure

package/lib/runtime/GetChunkFilenameRuntimeModule.js

@@ -67,6 +67,15 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 		}
 	}
 
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		return RuntimeModule.NO_CHUNK_HANDLERS;
+	}
+
 	/**
 	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code

package/lib/runtime/GetFullHashRuntimeModule.js

@@ -26,6 +26,15 @@ class GetFullHashRuntimeModule extends RuntimeModule {
 		return false;
 	}
 
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		return RuntimeModule.NO_CHUNK_HANDLERS;
+	}
+
 	/**
 	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code

package/lib/runtime/GetMainFilenameRuntimeModule.js

@@ -35,6 +35,15 @@ class GetMainFilenameRuntimeModule extends RuntimeModule {
 		this.filename = filename;
 	}
 
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		return RuntimeModule.NO_CHUNK_HANDLERS;
+	}
+
 	/**
 	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code

package/lib/runtime/GetWorkletBootstrapRuntimeModule.js

@@ -33,6 +33,15 @@ class GetWorkletBootstrapRuntimeModule extends RuntimeModule {
 		return false;
 	}
 
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		return RuntimeModule.NO_CHUNK_HANDLERS;
+	}
+
 	/**
 	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code