webpack 5.108.4 → 5.109.1

package/lib/prefetch/ResourceHintRuntimeModule.js

@@ -0,0 +1,149 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const { SyncWaterfallHook } = require("tapable");
+const Compilation = require("../Compilation");
+const RuntimeGlobals = require("../RuntimeGlobals");
+const RuntimeModule = require("../RuntimeModule");
+const Template = require("../Template");
+
+/**
+ * @typedef {object} ResourceHintRuntimeModulePluginHooks
+ * @property {SyncWaterfallHook<[string]>} linkPrefetch
+ * @property {SyncWaterfallHook<[string]>} linkPreload
+ */
+
+/** @type {WeakMap<Compilation, ResourceHintRuntimeModulePluginHooks>} */
+const compilationHooksMap = new WeakMap();
+
+/**
+ * Maps a request/filename to the value of the `<link>` `as` attribute. Best
+ * effort — falls back to `"fetch"` when the type cannot be guessed. Pattern
+ * matches against the path part, ignoring any query string suffix.
+ * @param {string} request request/filename
+ * @returns {string} value for the `as` attribute
+ */
+const guessAsAttribute = (request) => {
+	if (/\.(png|jpe?g|gif|svg|webp|avif|bmp|ico|tiff?)(\?.*)?$/i.test(request)) {
+		return "image";
+	}
+	if (/\.(woff2?|ttf|otf|eot)(\?.*)?$/i.test(request)) return "font";
+	if (/\.css(\?.*)?$/i.test(request)) return "style";
+	if (/\.[cm]?jsx?(\?.*)?$/i.test(request)) return "script";
+	if (/\.[cm]?tsx?(\?.*)?$/i.test(request)) return "script";
+	if (/\.(mp3|wav|flac|aac|m4a|ogg|oga)(\?.*)?$/i.test(request)) return "audio";
+	if (/\.(mp4|webm|mkv|mov|m4v|ogv|avi)(\?.*)?$/i.test(request)) return "video";
+	if (/\.vtt(\?.*)?$/i.test(request)) return "track";
+	return "fetch";
+};
+
+class ResourceHintRuntimeModule extends RuntimeModule {
+	/**
+	 * @param {Compilation} compilation the compilation
+	 * @returns {ResourceHintRuntimeModulePluginHooks} hooks
+	 */
+	static getCompilationHooks(compilation) {
+		if (!(compilation instanceof Compilation)) {
+			throw new TypeError(
+				"The 'compilation' argument must be an instance of Compilation"
+			);
+		}
+		let hooks = compilationHooksMap.get(compilation);
+		if (hooks === undefined) {
+			hooks = {
+				linkPrefetch: new SyncWaterfallHook(["source"]),
+				linkPreload: new SyncWaterfallHook(["source"])
+			};
+			compilationHooksMap.set(compilation, hooks);
+		}
+		return hooks;
+	}
+
+	/**
+	 * @param {"prefetch" | "preload"} rel link rel value
+	 */
+	constructor(rel) {
+		super(`asset ${rel}`, RuntimeModule.STAGE_ATTACH);
+		this._rel = rel;
+	}
+
+	/**
+	 * Generates runtime code for this runtime module.
+	 * @returns {string | null} runtime code
+	 */
+	generate() {
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const { runtimeTemplate, outputOptions } = compilation;
+		const { crossOriginLoading } = outputOptions;
+		const isNeutralPlatform = runtimeTemplate.isNeutralPlatform();
+		const rel = this._rel;
+		const fnName =
+			rel === "prefetch"
+				? RuntimeGlobals.prefetchAsset
+				: RuntimeGlobals.preloadAsset;
+		const hook =
+			ResourceHintRuntimeModule.getCompilationHooks(compilation)[
+				rel === "prefetch" ? "linkPrefetch" : "linkPreload"
+			];
+
+		const body = [
+			"if (installed[href]) return href;",
+			"installed[href] = 1;",
+			hook.call(
+				Template.asString([
+					"var link = document.createElement('link');",
+					`link.rel = ${JSON.stringify(rel)};`,
+					"link.href = href;",
+					"if (as) link.as = as;",
+					"if (type) link.type = type;",
+					"if (media) link.media = media;",
+					"if (fetchPriority) {",
+					Template.indent([
+						'link.setAttribute("fetchpriority", fetchPriority);'
+					]),
+					"}",
+					`if (${RuntimeGlobals.scriptNonce}) {`,
+					Template.indent(
+						`link.setAttribute("nonce", ${RuntimeGlobals.scriptNonce});`
+					),
+					"}",
+					crossOriginLoading
+						? crossOriginLoading === "use-credentials"
+							? 'link.crossOrigin = "use-credentials";'
+							: Template.asString([
+									"if (link.href.indexOf(window.location.origin + '/') !== 0) {",
+									Template.indent(
+										`link.crossOrigin = ${JSON.stringify(crossOriginLoading)};`
+									),
+									"}"
+								])
+						: ""
+				])
+			),
+			"document.head.appendChild(link);",
+			"return href;"
+		];
+
+		const fnBody = isNeutralPlatform
+			? ["if (typeof document === 'undefined') return href;", ...body]
+			: body;
+
+		// `Object.create(null)` keeps the dedupe map free of inherited
+		// properties (`toString`, `__proto__`, …) so any URL string is a
+		// safe key.
+		return Template.asString([
+			"var installed = Object.create(null);",
+			`${fnName} = ${runtimeTemplate.basicFunction(
+				"href, as, type, media, fetchPriority",
+				fnBody
+			)};`
+		]);
+	}
+}
+
+ResourceHintRuntimeModule.guessAsAttribute = guessAsAttribute;
+
+module.exports = ResourceHintRuntimeModule;

package/lib/prefetch/StartupAssetHintRuntimeModule.js

@@ -0,0 +1,210 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const RuntimeModule = require("../RuntimeModule");
+const Template = require("../Template");
+const CssUrlDependency = require("../dependencies/CssUrlDependency");
+const HtmlSourceDependency = require("../dependencies/HtmlSourceDependency");
+const URLDependency = require("../dependencies/URLDependency");
+const ResourceHintRuntimeModule = require("./ResourceHintRuntimeModule");
+
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+
+/**
+ * Fires `<link rel="prefetch">` / `<link rel="preload">` for every asset
+ * referenced from this chunk via `new URL(..., import.meta.url)` carrying
+ * `webpackPrefetch` / `webpackPreload`, at chunk startup. Runs before any
+ * user module evaluates, so by the time user code reaches the
+ * corresponding `new URL(...)` (or hands the URL to `<img>`, `fetch`,
+ * `new Worker`, etc.), the browser already has the response in flight.
+ */
+class StartupAssetHintRuntimeModule extends RuntimeModule {
+	constructor() {
+		super("startup asset hints", RuntimeModule.STAGE_TRIGGER);
+	}
+
+	/**
+	 * Generates runtime code for this runtime module.
+	 * @returns {string | null} runtime code
+	 */
+	generate() {
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const chunkGraph = /** @type {ChunkGraph} */ (this.chunkGraph);
+		const moduleGraph = /** @type {ModuleGraph} */ (compilation.moduleGraph);
+		const runtimeTemplate = compilation.runtimeTemplate;
+		const chunk = /** @type {Chunk} */ (this.chunk);
+		const runtimeRequirements =
+			/** @type {Set<string>} */
+			(chunkGraph.getTreeRuntimeRequirements(chunk));
+
+		// Dedupe per asset module: if the same asset is referenced twice
+		// (e.g. CSS rule says `prefetch`, a JS magic comment says
+		// `preload`), pick `preload` over `prefetch` and keep the most
+		// recently seen explicit attribute overrides. Avoids emitting a
+		// duplicate `<link>` and ordering-dependent winners.
+		/**
+		 * @typedef {object} AssetHintEntry
+		 * @property {import("../Module")} assetModule
+		 * @property {string} request
+		 * @property {boolean} preload
+		 * @property {("low" | "high" | "auto" | undefined)} fetchPriority
+		 * @property {(string | undefined)} as
+		 * @property {(string | undefined)} type
+		 * @property {(string | undefined)} media
+		 */
+		// Per-asset dedupe vs the HTML-head emission by `HtmlEntryDependency`:
+		// if the asset is reachable from an HTML entrypoint's chunks, its
+		// `<link>` lands in that HTML `<head>` already — skip the runtime
+		// hint for that asset so the DOM doesn't carry two tags for one URL.
+		// Set is computed once per compilation from the module graph (stable
+		// across cache reads), never from a mutable cross-module marker.
+		const ResourceHintPlugin = require("./ResourceHintPlugin");
+
+		// `output.resourceHints: "none"` is a hard off switch — the plugin's
+		// runtime-requirements hook already skips adding this module then, so no
+		// `"none"` guard is needed here.
+		const { isHtmlHinted } =
+			ResourceHintPlugin.getCompilationResolver(compilation);
+
+		/** @type {Map<string, AssetHintEntry>} */
+		const perAsset = new Map();
+		for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
+			const deps =
+				/** @type {{ dependencies?: import("../Dependency")[] }} */
+				(module).dependencies;
+			if (!deps) continue;
+			for (const dep of deps) {
+				if (
+					!(dep instanceof URLDependency) &&
+					!(dep instanceof CssUrlDependency) &&
+					!(dep instanceof HtmlSourceDependency)
+				) {
+					continue;
+				}
+				if (!dep.prefetch && !dep.preload) continue;
+				const assetModule = moduleGraph.getModule(dep);
+				if (!assetModule) continue;
+				if (isHtmlHinted(assetModule)) continue;
+				const key = assetModule.identifier();
+				const urlDep =
+					/** @type {URLDependency & Partial<CssUrlDependency> & Partial<HtmlSourceDependency>} */
+					(dep);
+				const existing = perAsset.get(key);
+				if (existing) {
+					if (dep.preload) existing.preload = true;
+					if (dep.fetchPriority) existing.fetchPriority = dep.fetchPriority;
+					if (urlDep.asAttribute) existing.as = urlDep.asAttribute;
+					if (urlDep.typeAttribute) existing.type = urlDep.typeAttribute;
+					if (urlDep.mediaAttribute) existing.media = urlDep.mediaAttribute;
+				} else {
+					perAsset.set(key, {
+						assetModule: /** @type {Module} */ (assetModule),
+						request: dep.request,
+						preload: Boolean(dep.preload),
+						fetchPriority: dep.fetchPriority,
+						as: urlDep.asAttribute,
+						type: urlDep.typeAttribute,
+						media: urlDep.mediaAttribute
+					});
+				}
+			}
+		}
+		const lines = [];
+		for (const entry of perAsset.values()) {
+			const fn = entry.preload
+				? RuntimeGlobals.preloadAsset
+				: RuntimeGlobals.prefetchAsset;
+			// For CSS-only assets (referenced from `url(...)` but never
+			// from JS) the module produces no JS source, so
+			// `__webpack_require__(id)` would throw at runtime. Use the
+			// emitted filename + publicPath directly in that case; asset
+			// modules referenced from JS stay on the existing `moduleRaw`
+			// path which yields the same URL.
+			const hasJsSourceType = entry.assetModule
+				.getSourceTypes()
+				.has("javascript");
+			let hrefExpr;
+			if (hasJsSourceType) {
+				hrefExpr = runtimeTemplate.moduleRaw({
+					chunkGraph,
+					module: entry.assetModule,
+					request: entry.request,
+					runtimeRequirements,
+					weak: false
+				});
+			} else {
+				const buildInfo =
+					/** @type {{ filename?: string }} */
+					(entry.assetModule.buildInfo);
+				if (!buildInfo || !buildInfo.filename) continue;
+				runtimeRequirements.add(RuntimeGlobals.publicPath);
+				hrefExpr = `${RuntimeGlobals.publicPath} + ${JSON.stringify(buildInfo.filename)}`;
+			}
+			const as =
+				entry.as || ResourceHintRuntimeModule.guessAsAttribute(entry.request);
+			lines.push(
+				`${fn}(${hrefExpr}, ${JSON.stringify(as)}, ${
+					entry.type ? JSON.stringify(entry.type) : "undefined"
+				}, ${entry.media ? JSON.stringify(entry.media) : "undefined"}, ${
+					entry.fetchPriority
+						? JSON.stringify(entry.fetchPriority)
+						: "undefined"
+				});`
+			);
+		}
+		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`.
+		const { module: isModule, importMetaName } = compilation.outputOptions;
+		const nonceSetup = isModule
+			? [
+					"if (typeof document !== 'undefined') {",
+					Template.indent([
+						`var url = ${importMetaName}.url;`,
+						"var scripts = document.getElementsByTagName('script');",
+						"for (var i = 0; i < scripts.length; i++) {",
+						Template.indent([
+							`if (scripts[i].src === url && scripts[i].nonce && !${RuntimeGlobals.scriptNonce}) {`,
+							Template.indent([
+								`${RuntimeGlobals.scriptNonce} = scripts[i].nonce;`,
+								"break;"
+							]),
+							"}"
+						]),
+						"}"
+					]),
+					"}"
+				]
+			: [
+					"if (typeof document !== 'undefined') {",
+					Template.indent([
+						"var currentScript = document.currentScript;",
+						`if (currentScript && currentScript.nonce && !${RuntimeGlobals.scriptNonce}) {`,
+						Template.indent(
+							`${RuntimeGlobals.scriptNonce} = currentScript.nonce;`
+						),
+						"}"
+					]),
+					"}"
+				];
+		return Template.asString([...nonceSetup, ...lines]);
+	}
+}
+
+module.exports = StartupAssetHintRuntimeModule;

package/lib/prefetch/parseResourceHintOptions.js

@@ -0,0 +1,103 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const UnsupportedFeatureWarning = require("../errors/UnsupportedFeatureWarning");
+
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../NormalModule")} NormalModule */
+
+/**
+ * @typedef {object} ResourceHintOptions
+ * @property {true=} prefetch
+ * @property {true=} preload
+ * @property {("high" | "low" | "auto")=} fetchPriority
+ * @property {string=} as
+ * @property {string=} type
+ * @property {string=} media
+ */
+
+/**
+ * Reads `webpackPrefetch` / `webpackPreload` / `webpackFetchPriority` /
+ * `webpackAs` / `webpackType` / `webpackMedia` from a parsed magic-comment
+ * options object. Invalid values emit warnings to the given module.
+ * @param {Record<string, EXPECTED_ANY> | null | undefined} importOptions parsed comment options
+ * @param {NormalModule} module the module to attach warnings to
+ * @param {DependencyLocation} loc location for warnings
+ * @returns {ResourceHintOptions} parsed hints (empty when no comments matched)
+ */
+const parseResourceHintOptions = (importOptions, module, loc) => {
+	/** @type {ResourceHintOptions} */
+	const hints = {};
+	if (!importOptions) return hints;
+
+	/**
+	 * @param {string} message warning text
+	 * @returns {void}
+	 */
+	const warn = (message) => {
+		module.addWarning(new UnsupportedFeatureWarning(message, loc));
+	};
+
+	if (importOptions.webpackPrefetch !== undefined) {
+		if (importOptions.webpackPrefetch === true) {
+			hints.prefetch = true;
+		} else {
+			warn(
+				`\`webpackPrefetch\` expected true, but received: ${importOptions.webpackPrefetch}.`
+			);
+		}
+	}
+	if (importOptions.webpackPreload !== undefined) {
+		if (importOptions.webpackPreload === true) {
+			hints.preload = true;
+		} else {
+			warn(
+				`\`webpackPreload\` expected true, but received: ${importOptions.webpackPreload}.`
+			);
+		}
+	}
+	if (importOptions.webpackFetchPriority !== undefined) {
+		const fp = importOptions.webpackFetchPriority;
+		if (fp === "high" || fp === "low" || fp === "auto") {
+			hints.fetchPriority = fp;
+		} else {
+			warn(
+				`\`webpackFetchPriority\` expected "low", "high" or "auto", but received: ${fp}.`
+			);
+		}
+	}
+	if (importOptions.webpackAs !== undefined) {
+		if (typeof importOptions.webpackAs === "string") {
+			hints.as = importOptions.webpackAs;
+		} else {
+			warn(
+				`\`webpackAs\` expected a string, but received: ${importOptions.webpackAs}.`
+			);
+		}
+	}
+	if (importOptions.webpackType !== undefined) {
+		if (typeof importOptions.webpackType === "string") {
+			hints.type = importOptions.webpackType;
+		} else {
+			warn(
+				`\`webpackType\` expected a string, but received: ${importOptions.webpackType}.`
+			);
+		}
+	}
+	if (importOptions.webpackMedia !== undefined) {
+		if (typeof importOptions.webpackMedia === "string") {
+			hints.media = importOptions.webpackMedia;
+		} else {
+			warn(
+				`\`webpackMedia\` expected a string, but received: ${importOptions.webpackMedia}.`
+			);
+		}
+	}
+
+	return hints;
+};
+
+module.exports = parseResourceHintOptions;

package/lib/rules/RuleSetCompiler.js

@@ -12,6 +12,7 @@ const { SyncHook } = require("tapable");
 /** @typedef {import("../../declarations/WebpackOptions").RuleSetUseItem} RuleSetUseItem */
 /** @typedef {import("../../declarations/WebpackOptions").RuleSetLoaderOptions} RuleSetLoaderOptions */
 /** @typedef {import("../../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
+/** @typedef {import("../../declarations/WebpackOptions").RuleSetConditionAbsolute} RuleSetConditionAbsolute */
 
 /** @typedef {(Falsy | RuleSetRule)[]} RuleSetRules */
 
@@ -461,6 +462,119 @@ class RuleSetCompiler {
 			`Compiling RuleSet failed: ${message} (at ${path}: ${value})`
 		);
 	}
+
+	/**
+	 * Best-effort detection of a user-registered loader (or explicit module type)
+	 * for a resource, without building the whole rule set. Used to resolve the
+	 * `experiments.css`/`experiments.html`/`experiments.asyncWebAssembly` "auto"
+	 * defaults: when the user already handles these files the built-in module type
+	 * stays off, so enabling it by default is non-breaking.
+	 *
+	 * `include`/`exclude` are treated leniently — a matching `test`/`resource`/
+	 * `include` with a loader counts even when another condition would narrow it —
+	 * so a loader scoped to e.g. `include: /src/` still keeps the built-in type off
+	 * and those files are not double-processed. `enforce: "pre"`/`"post"` loaders
+	 * are ignored: they don't establish the module type (e.g. a stylelint pre-loader
+	 * must not suppress the built-in css type). A `test` regexp that references the
+	 * extension (e.g. `/source\.css$/`) also counts even if the sample path itself
+	 * doesn't match, so a loader scoped to specific filenames is still detected.
+	 * @param {import("../../declarations/WebpackOptions").RuleSetRules | undefined} rules user `module.rules`
+	 * @param {string} resource sample resource path (e.g. `"/file.css"`)
+	 * @param {boolean=} inherited whether an enclosing rule already matched the resource
+	 * @returns {boolean} whether a rule assigns a loader or module type to the resource
+	 */
+	static hasRuleForResource(rules, resource, inherited = false) {
+		if (!rules) return false;
+		// `\.css` for `/file.css`, `\.wasm` for `/file.wasm`, …
+		const extProbe = `\\.${resource.slice(resource.lastIndexOf(".") + 1)}`;
+		for (const rule of rules) {
+			if (!rule || typeof rule !== "object") continue;
+			const matched =
+				inherited ||
+				matchesResource(rule.test, resource, extProbe) ||
+				matchesResource(rule.resource, resource, extProbe) ||
+				matchesResource(rule.include, resource, extProbe);
+			const establishesType =
+				rule.type !== undefined ||
+				((rule.use !== undefined || rule.loader !== undefined) &&
+					rule.enforce === undefined);
+			if (matched && establishesType) return true;
+			if (
+				rule.oneOf &&
+				RuleSetCompiler.hasRuleForResource(rule.oneOf, resource, matched)
+			) {
+				return true;
+			}
+			if (
+				rule.rules &&
+				RuleSetCompiler.hasRuleForResource(rule.rules, resource, matched)
+			) {
+				return true;
+			}
+		}
+		return false;
+	}
 }
 
+// Bare compiler reused to match single conditions via `compileCondition`
+// (no plugins needed); created lazily on first use.
+/** @type {RuleSetCompiler | undefined} */
+let conditionCompiler;
+
+/**
+ * Matches a single rule condition against a sample string, reusing the ruleset
+ * condition logic (string/regexp/function/array/and/or/not).
+ * @param {RuleSetConditionAbsolute | undefined} condition condition
+ * @param {string} resource sample resource path
+ * @returns {boolean} whether the condition matches
+ */
+const matchRuleSetCondition = (condition, resource) => {
+	if (condition === undefined) return false;
+	if (conditionCompiler === undefined) {
+		conditionCompiler = new RuleSetCompiler([]);
+	}
+	try {
+		return conditionCompiler
+			.compileCondition("ruleSet", condition)
+			.fn(resource);
+	} catch (_err) {
+		return false;
+	}
+};
+
+/**
+ * Whether any regexp 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.
+ * @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 (Array.isArray(condition)) {
+		return condition.some((c) => conditionReferencesExtension(c, extProbe));
+	}
+	if (condition && typeof condition === "object") {
+		return (
+			conditionReferencesExtension(condition.and, extProbe) ||
+			conditionReferencesExtension(condition.or, extProbe)
+		);
+	}
+	return false;
+};
+
+/**
+ * A condition counts as targeting the resource if it matches the sample path or
+ * references the extension via a regexp.
+ * @param {RuleSetConditionAbsolute | undefined} condition condition
+ * @param {string} resource sample resource path
+ * @param {string} extProbe escaped extension probe (e.g. `"\\.css"`)
+ * @returns {boolean} whether the condition targets the resource's extension
+ */
+const matchesResource = (condition, resource, extProbe) =>
+	condition !== undefined &&
+	(matchRuleSetCondition(condition, resource) ||
+		conditionReferencesExtension(condition, extProbe));
+
 module.exports = RuleSetCompiler;

package/lib/runtime/AsyncModuleGeneratorRuntimeModule.js

@@ -0,0 +1,56 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const Template = require("../Template");
+const HelperRuntimeModule = require("./HelperRuntimeModule");
+
+/** @typedef {import("../Compilation")} Compilation */
+
+class AsyncModuleGeneratorRuntimeModule extends HelperRuntimeModule {
+	constructor() {
+		super("async module generator");
+	}
+
+	/**
+	 * Generates runtime code for this runtime module.
+	 * @returns {string | null} runtime code
+	 */
+	generate() {
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const { runtimeTemplate } = compilation;
+		const fn = RuntimeGlobals.asyncModuleGenerator;
+		const cst = runtimeTemplate.renderConst();
+		// Wrap a generator-based async module body so it drives like an `async`
+		// function: run the generator and resolve each `yield`ed dependency
+		// promise, without emitting `async`/`await`.
+		return Template.asString([
+			`${fn} = ${runtimeTemplate.returningFunction(
+				runtimeTemplate.basicFunction(
+					"__webpack_handle_async_dependencies__, __webpack_async_result__",
+					[
+						`${cst} gen = body(__webpack_handle_async_dependencies__, __webpack_async_result__);`,
+						`${cst} step = ${runtimeTemplate.basicFunction("key, arg", [
+							`${cst} info = gen[key](arg);`,
+							"if (info.done) return;",
+							`Promise.resolve(info.value).then(${runtimeTemplate.expressionFunction(
+								'step("next", value)',
+								"value"
+							)}, ${runtimeTemplate.expressionFunction(
+								'step("throw", err)',
+								"err"
+							)});`
+						])};`,
+						'step("next");'
+					]
+				),
+				"body"
+			)};`
+		]);
+	}
+}
+
+module.exports = AsyncModuleGeneratorRuntimeModule;