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

package/lib/prefetch/ResourceHintPlugin.js

@@ -300,7 +300,12 @@ const collectEntrypointHints = (compilation, entryName, hints) => {
 	const out = [];
 	/** @type {Set<string>} */
 	const seenKeys = new Set();
-	const push = (/** @type {EntrypointHint} */ h) => {
+	/**
+	 * Appends a hint, dropping one already emitted for the same rel + href.
+	 * @param {EntrypointHint} h hint to append
+	 * @returns {void}
+	 */
+	const push = (h) => {
 		const key = `${h.rel}\0${h.href}`;
 		if (seenKeys.has(key)) return;
 		seenKeys.add(key);
@@ -380,10 +385,9 @@ const collectEntrypointHints = (compilation, entryName, hints) => {
 		if (dep.fetchPriority) h.fetchPriority = dep.fetchPriority;
 		push(h);
 	}
-	// `hostType`: `"html"` iff the entrypoint has an extracted HTML page
-	// (any `HtmlEntryDependency` with elementKind `script`/`script-module` on
-	// any HTML module points at this entryName); SSR frameworks reading
-	// `stats.entrypoints[name].resourceHints` see `"js"`.
+	// `hostType` is `"html"` only where the entrypoint has an extracted page, that
+	// is where some HTML module's script dependency names this entry. An SSR
+	// framework reading the stats sees `"js"`.
 	let hostType = /** @type {"html" | "js"} */ ("js");
 
 	outer: for (const module of compilation.modules) {
@@ -481,19 +485,12 @@ const collectStartupAssetHintLines = (
 				seenWorkerChunks.add(workerChunk.id);
 				// The same specifier the `new Worker(...)` call site bakes, asked of the
 				// same module, so the two agree on whether a literal is spellable.
-				const specifier = runtimeTemplate.supportsAnalyzable(
-					"url",
-					chunkGraph,
-					module
-				)
-					? runtimeTemplate._getAnalyzableChunkSpecifier(
-							dep.options.publicPath,
-							workerChunk,
-							module,
-							chunkGraph,
-							set
-						)
-					: null;
+				const specifier = runtimeTemplate.getAnalyzableWorkerUrl(
+					dep.options.publicPath,
+					workerChunk,
+					module,
+					chunkGraph
+				);
 				// Without one the call site keeps the runtime form, where it wraps its own
 				// href — firing the `<link>` here too would emit the call twice.
 				if (specifier === null) continue;
@@ -739,15 +736,14 @@ class ResourceHintPlugin {
 		const hints = this._hints;
 
 		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
-			// Lazy-computed on first access — walk every HTML module's
-			// `HtmlEntryDependency`s, resolve each named entry, and collect
-			// every URL asset dep target reachable from its ordered chunks.
-			// One pass produces two views: a per-entry list (consumed by
-			// `HtmlEntryDependency.Template` to emit `<link>` tags) and a
-			// global `WeakSet` (consumed by `StartupAssetHintRuntimeModule`
-			// to skip the JS runtime `<link>` for the same asset).
-			// Deterministic (module graph is fixed by seal time) and cheap
-			// (only fires when a JS chunk actually produces hints).
+			// WHY: computed on first access. One walk of every HTML module's
+			// `HtmlEntryDependency`s — resolving each named entry and collecting every
+			// URL asset dep reachable from its ordered chunks — yields both views: a
+			// per-entry list, which `HtmlEntryDependency.Template` emits the `<link>`
+			// tags from, and a global `WeakSet`, which `StartupAssetHintRuntimeModule`
+			// reads to skip the JS runtime `<link>` for the same asset. Deterministic,
+			// the module graph being fixed by seal time, and cheap, since it only fires
+			// when a JS chunk actually produces hints.
 			/** @type {Map<string, HtmlHintedAsset[]> | undefined} */
 			let perEntry;
 			/** @type {WeakSet<Module> | undefined} */
@@ -775,10 +771,9 @@ class ResourceHintPlugin {
 						}
 						const entrypoint = compilation.entrypoints.get(dep.entryName);
 						if (!entrypoint) continue;
-						// Mirror `getEntrypointChunksInLoadOrder`: entry chunk +
-						// runtime chunk + all initial siblings (`entrypoint.chunks`
-						// includes splitChunks output). Async `import()` chunks
-						// stay on the on-demand runtime and are NOT HTML-hinted.
+						// Mirrors `getEntrypointChunksInLoadOrder`: the entry, runtime and
+						// every initial sibling. An async `import()` chunk stays on the
+						// on-demand runtime and is never HTML-hinted.
 						/** @type {Set<import("../Chunk")>} */
 						const chunks = new Set(entrypoint.chunks);
 						const entry = entrypoint.getEntrypointChunk();
@@ -866,10 +861,9 @@ class ResourceHintPlugin {
 					});
 			}
 
-			// SSR manifest: serialize each entrypoint's resolved hints to a JSON
-			// asset (the same descriptors as `stats.entrypoints[].resourceHints`)
-			// so an SSR server can inject the `<link>` tags itself. `"none"`
-			// yields empty lists (via `collectEntrypointHints`).
+			// The SSR manifest serializes each entrypoint's resolved hints to a JSON
+			// asset, the same descriptors the stats carry, so an SSR server can inject
+			// the tags itself. `"none"` yields empty lists.
 			const rhOptions = compilation.outputOptions.resourceHints;
 			const manifestPath = rhOptions && rhOptions.manifest;
 			if (manifestPath) {

package/lib/prefetch/ResourceHintRuntimeModule.js

@@ -50,6 +50,15 @@ class ResourceHintRuntimeModule extends RuntimeModule {
 		this._rel = rel;
 	}
 
+	/**
+	 * 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/prefetch/StartupAssetHintRuntimeModule.js

@@ -30,6 +30,15 @@ class StartupAssetHintRuntimeModule extends RuntimeModule {
 		this._lines = lines;
 	}
 
+	/**
+	 * 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
@@ -38,16 +47,13 @@ class StartupAssetHintRuntimeModule extends RuntimeModule {
 		const compilation = /** @type {Compilation} */ (this.compilation);
 		const lines = this._lines;
 		if (lines.length === 0) return null;
-		// `__webpack_nonce__` set inside the entry module is too late — the
-		// entry hasn't run yet. Read the nonce off the `<script>` tag that
-		// loaded the bundle, so prefetch / preload links match a CSP that
-		// demands the same nonce as the script.
-		//
-		// - For classic script output, `document.currentScript` is the
-		//   loading `<script>` element while the runtime executes.
-		// - For ESM output (`output.module: true`), `document.currentScript`
-		//   is `null`; locate the loading `<script type="module">` by
-		//   matching `script.src` against `import.meta.url`.
+		// `__webpack_nonce__` set in the entry module comes too late, the entry not
+		// having run, so the nonce is read off the `<script>` that loaded the bundle
+		// and the links match a CSP demanding the script's own.
+
+		// Classic output finds it on `document.currentScript`. ESM output leaves that
+		// null, so the loading `<script type="module">` is found by matching its
+		// `src` against `import.meta.url`.
 		const { module: isModule, importMetaName } = compilation.outputOptions;
 		const nonceSetup = isModule
 			? [

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,96 @@ 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"
+					)}`,
+					// The sync require wrapper clears `module.evaluating` the moment `.a`
+					// returns, so a deferred namespace reaching this module through a cycle
+					// needs `evaluatingAsync` to keep throwing until evaluation ends.
+					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