webpack 5.110.3 → 5.111.0

package/lib/performance/isOnlyReexported.js

@@ -0,0 +1,65 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const HarmonyExportImportedSpecifierDependency = require("../dependencies/HarmonyExportImportedSpecifierDependency");
+const HarmonyImportDependency = require("../dependencies/HarmonyImportDependency");
+
+/** @import Module from "../Module" */
+/** @import ModuleGraph from "../ModuleGraph" */
+
+/**
+ * Tells whether every module pulling this one in does so by re-exporting it.
+ * One an importer wants for its side effects alone is deliberate, not a
+ * barrel's leftover.
+ * @param {Module} module the module to look up
+ * @param {ModuleGraph} moduleGraph the module graph
+ * @returns {boolean} true when only re-exports pull it in
+ */
+const isOnlyReexported = (module, moduleGraph) => {
+	// A re-export emits a side-effect edge of its own, so edges are grouped by
+	// the statement they come from — `sourceOrder` — rather than by their type.
+	/** @type {Map<Module, Set<number | undefined>>} */
+	const reexportedStatements = new Map();
+	/** @type {[Module, number | undefined][]} */
+	const edges = [];
+
+	for (const connection of moduleGraph.getIncomingConnections(module)) {
+		const origin = connection.originModule;
+
+		// An entry has no origin: it is in the build because it was asked for.
+		if (!origin) return false;
+
+		const dependency = connection.dependency;
+
+		// Only an ESM import statement can carry a re-export.
+		if (!(dependency instanceof HarmonyImportDependency)) return false;
+
+		if (dependency instanceof HarmonyExportImportedSpecifierDependency) {
+			const statements = reexportedStatements.get(origin);
+
+			if (statements === undefined) {
+				reexportedStatements.set(origin, new Set([dependency.sourceOrder]));
+			} else {
+				statements.add(dependency.sourceOrder);
+			}
+		}
+
+		edges.push([origin, dependency.sourceOrder]);
+	}
+
+	if (edges.length === 0) return false;
+
+	for (const [origin, sourceOrder] of edges) {
+		const statements = reexportedStatements.get(origin);
+
+		if (statements === undefined || !statements.has(sourceOrder)) return false;
+	}
+
+	return true;
+};
+
+module.exports = isOnlyReexported;

package/lib/prefetch/ChunkPrefetchFunctionRuntimeModule.js

@@ -6,6 +6,8 @@
 
 const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
+const { getOnlyHandlerKey } = require("../util/handlerKeys");
+const { propertyAccess } = require("../util/property");
 
 /** @import Compilation from "../Compilation" */
 
@@ -33,6 +35,17 @@ class ChunkPrefetchFunctionRuntimeModule extends RuntimeModule {
 		this.runtimeHandlers = runtimeHandlers;
 	}
 
+	/**
+	 * 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
@@ -41,17 +54,24 @@ class ChunkPrefetchFunctionRuntimeModule extends RuntimeModule {
 		const { runtimeFunction, runtimeHandlers } = this;
 		const compilation = /** @type {Compilation} */ (this.compilation);
 		const { runtimeTemplate } = compilation;
+		const only =
+			runtimeFunction === null
+				? null
+				: getOnlyHandlerKey(this, runtimeHandlers);
 		return Template.asString([
 			`${runtimeHandlers} = {};`,
 			...(runtimeFunction === null
 				? []
 				: [
 						`${runtimeFunction} = ${runtimeTemplate.basicFunction("chunkId", [
-							// map is shorter than forEach
-							`Object.keys(${runtimeHandlers}).map(${runtimeTemplate.basicFunction(
-								"key",
-								`${runtimeHandlers}[key](chunkId);`
-							)});`
+							// One handler needs no walk over the others, and most chunks carry one.
+							only === null
+								? // map is shorter than forEach
+									`Object.keys(${runtimeHandlers}).map(${runtimeTemplate.basicFunction(
+										"key",
+										`${runtimeHandlers}[key](chunkId);`
+									)});`
+								: `${runtimeHandlers}${propertyAccess([only])}(chunkId);`
 						])};`
 					])
 		]);

package/lib/prefetch/ChunkPrefetchPreloadPlugin.js

@@ -50,6 +50,8 @@ class ChunkPrefetchPreloadPlugin {
 					if (startupChildChunks) {
 						set.add(RuntimeGlobals.prefetchChunk);
 						set.add(RuntimeGlobals.onChunksLoaded);
+						// This is the one startup callback that is queued behind a priority.
+						set.add(RuntimeGlobals.hasChunkPriority);
 						set.add(RuntimeGlobals.exports);
 						compilation.addLazyRuntimeModule(
 							chunk,

package/lib/prefetch/ChunkPrefetchStartupRuntimeModule.js

@@ -21,6 +21,15 @@ class ChunkPrefetchStartupRuntimeModule extends RuntimeModule {
 		this.startupChunks = startupChunks;
 	}
 
+	/**
+	 * 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/ChunkPrefetchTriggerRuntimeModule.js

@@ -21,6 +21,15 @@ class ChunkPrefetchTriggerRuntimeModule extends RuntimeModule {
 		this.chunkMap = chunkMap;
 	}
 
+	/**
+	 * 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 [[RuntimeGlobals.ensureChunkHandlers, "prefetch"]];
+	}
+
 	/**
 	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code

package/lib/prefetch/ChunkPreloadTriggerRuntimeModule.js

@@ -24,6 +24,15 @@ class ChunkPreloadTriggerRuntimeModule extends RuntimeModule {
 		this.handlerKey = handlerKey;
 	}
 
+	/**
+	 * 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 [[RuntimeGlobals.ensureChunkHandlers, this.handlerKey]];
+	}
+
 	/**
 	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code

package/lib/prefetch/ResourceHintPlugin.js

@@ -490,8 +490,7 @@ const collectStartupAssetHintLines = (
 					dep.options.publicPath,
 					workerChunk,
 					module,
-					chunkGraph,
-					set
+					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.

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

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__")};`,
@@ -148,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);`
+				]
+			)};`
 		]);
 	}
 }